From: SourceForge.net <no...@so...> - 2009-08-27 14:43:00
|
Bugs item #2845605, was opened at 2009-08-27 08:43 Message generated for change (Tracker Item Submitted) made by peternhale You can respond by visiting: https://sourceforge.net/tracker/?func=detail&atid=115278&aid=2845605&group_id=15278 Please note that this message will contain a full copy of the comment thread, including the initial issue submission, for this request, not just the latest update. Category: test runner Group: None Status: Open Resolution: None Priority: 5 Private: No Submitted By: Peter Hale (peternhale) Assigned to: Nobody/Anonymous (nobody) Summary: Assume.assume* functions do not mark the test as ignored Initial Comment: I have some tests which only make sense to run if an object passed into the test is not null. Using the Assume.assumeNotNull seems like the sensible approach to controlling test execution, however, after the test has run there seems to be no way to distinguish between a test that was halted via assumeNotNull and one that passed. Given the test class: @RunWith(Parameterized.class) public class IgnoreThis { @Parameters public static List<Object[]> data() { return Arrays.asList(new Object[][]{{null}, {"not null"}}); } private Object o; public IgnoreThis(Object input) { this.o = input; } @Test public void assumeTrueIgnoredTest() { assumeNotNull(o); assertNotNull(o); } @Ignore @Test public void annotationIgnoredTest() { } } I was actually expecting the test which was halted by assumeNotNull to be reported differently than a test that passed. I may be reading too much into the javadoc, but it seems that using the Assume methods would yield the same reporting results as using the @Ignore annotation. ---------------------------------------------------------------------- You can respond by visiting: https://sourceforge.net/tracker/?func=detail&atid=115278&aid=2845605&group_id=15278 |
From: SourceForge.net <no...@so...> - 2009-08-27 15:04:22
|
Bugs item #2845619, was opened at 2009-08-27 09:04 Message generated for change (Tracker Item Submitted) made by peternhale You can respond by visiting: https://sourceforge.net/tracker/?func=detail&atid=115278&aid=2845619&group_id=15278 Please note that this message will contain a full copy of the comment thread, including the initial issue submission, for this request, not just the latest update. Category: test runner Group: None Status: Open Resolution: None Priority: 5 Private: No Submitted By: Peter Hale (peternhale) Assigned to: Nobody/Anonymous (nobody) Summary: Assume.assume* functions do not mark the test as ignored Initial Comment: I have some tests which only make sense to run if an object passed into the test is not null. Using the Assume.assumeNotNull seems like the sensible approach to controlling test execution, however, after the test has run there seems to be no way to distinguish between a test that was halted via assumeNotNull and one that passed. Given the test class: @RunWith(Parameterized.class) public class IgnoreThis { @Parameters public static List<Object[]> data() { return Arrays.asList(new Object[][]{{null}, {"not null"}}); } private Object o; public IgnoreThis(Object input) { this.o = input; } @Test public void assumeTrueIgnoredTest() { assumeNotNull(o); assertNotNull(o); } @Ignore @Test public void annotationIgnoredTest() { } } I was actually expecting the test which was halted by assumeNotNull to be reported differently than a test that passed. I may be reading too much into the javadoc, but it seems that using the Assume methods would yield the same reporting results as using the @Ignore annotation. ---------------------------------------------------------------------- You can respond by visiting: https://sourceforge.net/tracker/?func=detail&atid=115278&aid=2845619&group_id=15278 |
From: SourceForge.net <no...@so...> - 2009-08-27 15:05:26
|
Bugs item #2845619, was opened at 2009-08-27 09:04 Message generated for change (Settings changed) made by peternhale You can respond by visiting: https://sourceforge.net/tracker/?func=detail&atid=115278&aid=2845619&group_id=15278 Please note that this message will contain a full copy of the comment thread, including the initial issue submission, for this request, not just the latest update. Category: test runner Group: None >Status: Closed >Resolution: Duplicate Priority: 5 Private: No Submitted By: Peter Hale (peternhale) Assigned to: Nobody/Anonymous (nobody) Summary: Assume.assume* functions do not mark the test as ignored Initial Comment: I have some tests which only make sense to run if an object passed into the test is not null. Using the Assume.assumeNotNull seems like the sensible approach to controlling test execution, however, after the test has run there seems to be no way to distinguish between a test that was halted via assumeNotNull and one that passed. Given the test class: @RunWith(Parameterized.class) public class IgnoreThis { @Parameters public static List<Object[]> data() { return Arrays.asList(new Object[][]{{null}, {"not null"}}); } private Object o; public IgnoreThis(Object input) { this.o = input; } @Test public void assumeTrueIgnoredTest() { assumeNotNull(o); assertNotNull(o); } @Ignore @Test public void annotationIgnoredTest() { } } I was actually expecting the test which was halted by assumeNotNull to be reported differently than a test that passed. I may be reading too much into the javadoc, but it seems that using the Assume methods would yield the same reporting results as using the @Ignore annotation. ---------------------------------------------------------------------- You can respond by visiting: https://sourceforge.net/tracker/?func=detail&atid=115278&aid=2845619&group_id=15278 |
From: SourceForge.net <no...@so...> - 2009-11-16 17:45:22
|
Bugs item #2845605, was opened at 2009-08-27 10:43 Message generated for change (Comment added) made by dsaff You can respond by visiting: https://sourceforge.net/tracker/?func=detail&atid=115278&aid=2845605&group_id=15278 Please note that this message will contain a full copy of the comment thread, including the initial issue submission, for this request, not just the latest update. Category: test runner Group: None >Status: Pending Resolution: None Priority: 5 Private: No Submitted By: Peter Hale (peternhale) Assigned to: Nobody/Anonymous (nobody) Summary: Assume.assume* functions do not mark the test as ignored Initial Comment: I have some tests which only make sense to run if an object passed into the test is not null. Using the Assume.assumeNotNull seems like the sensible approach to controlling test execution, however, after the test has run there seems to be no way to distinguish between a test that was halted via assumeNotNull and one that passed. Given the test class: @RunWith(Parameterized.class) public class IgnoreThis { @Parameters public static List<Object[]> data() { return Arrays.asList(new Object[][]{{null}, {"not null"}}); } private Object o; public IgnoreThis(Object input) { this.o = input; } @Test public void assumeTrueIgnoredTest() { assumeNotNull(o); assertNotNull(o); } @Ignore @Test public void annotationIgnoredTest() { } } I was actually expecting the test which was halted by assumeNotNull to be reported differently than a test that passed. I may be reading too much into the javadoc, but it seems that using the Assume methods would yield the same reporting results as using the @Ignore annotation. ---------------------------------------------------------------------- >Comment By: David Saff (dsaff) Date: 2009-11-16 12:45 Message: This tracker is being shut down. Please move this item to http://github.com/KentBeck/junit/issues ---------------------------------------------------------------------- You can respond by visiting: https://sourceforge.net/tracker/?func=detail&atid=115278&aid=2845605&group_id=15278 |
From: SourceForge.net <no...@so...> - 2009-12-01 02:20:12
|
Bugs item #2845605, was opened at 2009-08-27 14:43 Message generated for change (Comment added) made by sf-robot You can respond by visiting: https://sourceforge.net/tracker/?func=detail&atid=115278&aid=2845605&group_id=15278 Please note that this message will contain a full copy of the comment thread, including the initial issue submission, for this request, not just the latest update. Category: test runner Group: None >Status: Closed Resolution: None Priority: 5 Private: No Submitted By: Peter Hale (peternhale) Assigned to: Nobody/Anonymous (nobody) Summary: Assume.assume* functions do not mark the test as ignored Initial Comment: I have some tests which only make sense to run if an object passed into the test is not null. Using the Assume.assumeNotNull seems like the sensible approach to controlling test execution, however, after the test has run there seems to be no way to distinguish between a test that was halted via assumeNotNull and one that passed. Given the test class: @RunWith(Parameterized.class) public class IgnoreThis { @Parameters public static List<Object[]> data() { return Arrays.asList(new Object[][]{{null}, {"not null"}}); } private Object o; public IgnoreThis(Object input) { this.o = input; } @Test public void assumeTrueIgnoredTest() { assumeNotNull(o); assertNotNull(o); } @Ignore @Test public void annotationIgnoredTest() { } } I was actually expecting the test which was halted by assumeNotNull to be reported differently than a test that passed. I may be reading too much into the javadoc, but it seems that using the Assume methods would yield the same reporting results as using the @Ignore annotation. ---------------------------------------------------------------------- >Comment By: SourceForge Robot (sf-robot) Date: 2009-12-01 02:20 Message: This Tracker item was closed automatically by the system. It was previously set to a Pending status, and the original submitter did not respond within 14 days (the time period specified by the administrator of this Tracker). ---------------------------------------------------------------------- Comment By: David Saff (dsaff) Date: 2009-11-16 17:45 Message: This tracker is being shut down. Please move this item to http://github.com/KentBeck/junit/issues ---------------------------------------------------------------------- You can respond by visiting: https://sourceforge.net/tracker/?func=detail&atid=115278&aid=2845605&group_id=15278 |