/** * Tests the {@link LaunchConfiguration#setName} method * * @throws Exception */ public void testSetName() throws Exception { assertEquals("The default name should be: 'Test'", config.getName(), "Test"); config.setNameProxy("newname"); assertEquals("The new name should be: 'newname'", config.getName(), "newname"); // reset the name config.setNameProxy("Test"); }
/** * Verifies that a list of three non-nested transactions all persist correctly. * * @throws Exception */ public void testPersistTransactions() throws Exception { AnzoClient client1 = new AnzoClient(TestConfiguration.getPersistenceConfiguration()); // client.setNotificationEnabled(false); try { client1.clear(); client1.begin(); ClientGraph replicaGraph = client1.getReplicaGraph(TestData.graph2); replicaGraph.add(TestData.stmt2); client1.commit(); client1.begin(); replicaGraph.add(TestData.stmt3); client1.commit(); client1.begin(); replicaGraph.add(TestData.stmt4); client1.commit(); } finally { client1.close(); } AnzoClient client2 = new AnzoClient(TestConfiguration.getPersistenceConfiguration()); try { assertEquals(3, client2.transactionQueue.committedTransactions.size()); ClientGraph graph = client2.getReplicaGraph(TestData.graph2); assertTrue(graph.contains(TestData.stmt2)); assertTrue(graph.contains(TestData.stmt3)); assertTrue(graph.contains(TestData.stmt4)); } finally { client2.close(); } }
@Test public void testExceptionHandlerWithFailIgnored() { Exception res = null; TestConfiguration testConf = new TestConfiguration(); testConf.setFailIgnored(true); try { ActionExceptionHandler.handleError(testConf, new TestAction(), "an error message."); } catch (ActionException e) { fail(); } assertTrue(res == null); }
@Test public void testGetPropertyAsDoubleExists() { final Configuration configuration = TestConfiguration.create("foo", "1.23"); final Optional<Double> value = configuration.getPropertyAsDouble("foo"); Assert.assertTrue(value.isPresent()); Assert.assertEquals(1.23d, value.get(), 0.001); }
@Test public void testGetPropertyAsBooleanExists() { final Configuration configuration = TestConfiguration.create("foo", "false"); final Optional<Boolean> value = configuration.getPropertyAsBoolean("foo"); Assert.assertTrue(value.isPresent()); Assert.assertFalse(value.get()); }
@Test public void testGetPropertyAsShortExists() { final Configuration configuration = TestConfiguration.create("foo", "1"); final Optional<Short> value = configuration.getPropertyAsShort("foo"); Assert.assertTrue(value.isPresent()); Assert.assertEquals(1, value.get().shortValue()); }
@Test public void testConvertMap() throws Exception { Map testMap = new HashedMap(); testMap.put("key1", "value1"); testMap.put("key2", "value2"); testMap.put("key3", "value3"); testConfiguration.setXsltParamTestMap(testMap); Map<String, String> result = converter.convert(testConfiguration); Assert.assertEquals(4, result.size()); String actualMapXml = result.get("testMap"); String entry1 = "<entry key=\"key1\" value=\"value1\"/>"; String entry2 = "<entry key=\"key2\" value=\"value2\"/>"; String entry3 = "<entry key=\"key3\" value=\"value3\"/>"; Assert.assertTrue(actualMapXml.contains(entry1)); Assert.assertTrue(actualMapXml.contains(entry2)); Assert.assertTrue(actualMapXml.contains(entry3)); Assert.assertTrue( actualMapXml .replace(entry1, "") .replace(entry2, "") .replace(entry3, "") .equals("<map></map>")); }
@Test public void testGetPropertyAsLongExists() { final Configuration configuration = TestConfiguration.create("foo", "1"); final Optional<Long> value = configuration.getPropertyAsLong("foo"); Assert.assertTrue(value.isPresent()); Assert.assertEquals(1L, value.get().longValue()); }
@Test public void testGetAsMissing() { final Configuration configuration = TestConfiguration.createNull(); @SuppressWarnings("unchecked") final Map<String, String> value = (Map<String, String>) configuration.getAs(Map.class, Collections.emptyMap()); Assert.assertTrue(value.isEmpty()); }
@Test public void testGetRequiredAsExists() { final Configuration configuration = TestConfiguration.create("foo", "bar"); @SuppressWarnings("unchecked") final Map<String, String> value = (Map<String, String>) configuration.getRequiredAs(Map.class); Assert.assertEquals(1, value.size()); Assert.assertEquals("bar", value.get("foo")); }
@Test public void testConvertPrimitives() throws Exception { String testString = "A test xslt string"; testConfiguration.setXsltParamTestString(testString); testConfiguration.setXsltParamTestInt(123); testConfiguration.setXsltParamTestBoolean(true); testConfiguration.setXsltParamTestLong(9999999999999l); Map<String, String> result = converter.convert(testConfiguration); Assert.assertEquals(4, result.size()); Assert.assertEquals(testString, result.get("testString")); Assert.assertEquals("123", result.get("testInt")); Assert.assertEquals("true", result.get("testBoolean")); Assert.assertEquals("9999999999999", result.get("testLong")); }
/** * verify a commit called with no begin is a no-op and does not throw an exception. * * @throws Exception */ public void testNoOpCommit() throws Exception { AnzoClient client = new AnzoClient(TestConfiguration.getBasicConfiguration()); try { client.clear(); client.commit(); } finally { client.close(); } }
/** * Decorate a set of tests to use a single use database with logDevice pointing a log directory to * non-default location */ public static Test logDeviceAttributeDatabase(Test test, final String logDevice) { Properties attributes = new Properties(); if (logDevice != null) { attributes.setProperty("logDevice", logDevice); } test = TestConfiguration.singleUseDatabaseDecorator(test); return attributesDatabase(attributes, test); }
/** * Decorate a test (or suite of tests) to use a single use database as the default database with a * specified set connection attributes. * * @param attributes properties to set in the connection URL or in the connectionAttributes of a * data source when connecting to the database * @param test Test to decorate * @return Decorated test */ public static Test attributesDatabase(final Properties attributes, Test test) { test = new ChangeConfigurationSetup(test) { TestConfiguration getNewConfiguration(TestConfiguration old) { return old.addConnectionAttributes(attributes); } }; return TestConfiguration.singleUseDatabaseDecorator(test); }
/** * Make sure an exception is thrown if an attempt is made to create more than one client that uses * the same container name, meaning they would be using the persistent database tables, which is * not allowed. * * @throws Exception */ public void testIllegalSharedDatabase() throws Exception { AnzoClient client1 = null; AnzoClient client2 = null; try { AnzoException exception = null; try { Properties properties = TestUtilities.getProperties(); AnzoClientProperties.setPersistenceEnabled(properties, true); client1 = new AnzoClient(TestConfiguration.getPersistenceConfiguration()); client2 = new AnzoClient(TestConfiguration.getPersistenceConfiguration()); } catch (AnzoException e) { exception = e; } assertNotNull(exception); } finally { if (client1 != null) client1.close(); if (client2 != null) client2.close(); } }
/** * Verifies that replicated Quads are persisted correctly. * * <p>See also testPersistTransaction, which verifies Quads that have not been replicated (and are * in the transaction queue) are persisted correctly. * * @throws Exception */ public void testPersistQuad() throws Exception { AnzoClient client1 = new AnzoClient(TestConfiguration.getPersistenceConfiguration()); // client.setNotificationEnabled(false); try { client1.clear(); ClientGraph graph = client1.getReplicaGraph(TestData.graph1); graph.add(TestData.stmt1); client1.quadStore.add(TestData.stmt1); } finally { client1.close(); } AnzoClient client2 = new AnzoClient(TestConfiguration.getPersistenceConfiguration()); // client2.setNotificationEnabled(false); try { ClientGraph graph = client2.getReplicaGraph(TestData.graph1); assertTrue(graph.contains(TestData.stmt1)); } finally { client2.close(); } }
/** * Verifies that all the fields of a precondition are persisted correctly. * * @throws Exception */ public void testPersistPrecondition() throws Exception { String preconditionQuery = "ASK WHERE (?s ?p ?o)"; AnzoClient client1 = new AnzoClient(TestConfiguration.getPersistenceConfiguration()); // client.setNotificationEnabled(false); try { client1.clear(); Precondition precondition = new Precondition( Collections.singleton(TestData.graph1), Collections.singleton(TestData.graph2), preconditionQuery, true); client1.begin(Collections.<IPrecondition>singleton(precondition)); ClientGraph replicaGraph = client1.getReplicaGraph(TestData.graph2); replicaGraph.add(TestData.stmt2); client1.commit(); } finally { client1.close(); } AnzoClient client2 = new AnzoClient(TestConfiguration.getPersistenceConfiguration()); try { Transaction transaction = client2.transactionQueue.committedTransactions.get(0); Set<IPrecondition> preconditions = transaction.preconditions; assertNotNull(preconditions); Iterator<IPrecondition> iterator = preconditions.iterator(); assertTrue(iterator.hasNext()); IPrecondition next = iterator.next(); assertEquals(preconditionQuery, next.getQuery()); assertTrue(next.getDefaultGraphUris().contains(TestData.graph1)); assertTrue(next.getNamedGraphUris().contains(TestData.graph2)); AskResult result = (AskResult) next.getResult(); assertTrue(result.getResultValue()); } finally { client2.close(); } }
/** Only called reflectively. Do not use programmatically. */ public Junit4TestFixtureRunner(Class<?> klass) throws Throwable { super(klass, Collections.<Runner>emptyList()); String restrictProperty = null; String restrictValue = null; Class<?> fixtureClass = null; String fixtureType = null; for (Annotation annotation : getTestClass().getAnnotations()) { if ("org.eclipse.mylyn.commons.sdk.util.Junit4TestFixtureRunner.OnlyRunWithProperty" .equals(annotation.annotationType().getCanonicalName())) { RunOnlyWhenProperty onlyWhenProperty = (RunOnlyWhenProperty) annotation; restrictProperty = onlyWhenProperty.property(); restrictValue = onlyWhenProperty.value(); } if ("org.eclipse.mylyn.commons.sdk.util.Junit4TestFixtureRunner.FixtureDefinition" .equals(annotation.annotationType().getCanonicalName())) { FixtureDefinition fixtueDef = (FixtureDefinition) annotation; fixtureClass = fixtueDef.fixtureClass(); fixtureType = fixtueDef.fixtureType(); } } if (fixtureType != null) { List<AbstractTestFixture> parametersList = (List<AbstractTestFixture>) TestConfiguration.getDefault().discover(fixtureClass, fixtureType); List<AbstractTestFixture> fixturesToExecute = new ArrayList<AbstractTestFixture>(); if (restrictProperty != null) { for (AbstractTestFixture abstractFixture : parametersList) { String tempProperty = abstractFixture.getProperty(restrictProperty); if (tempProperty != null && tempProperty.equals(restrictValue)) { fixturesToExecute.add(abstractFixture); } } if (fixturesToExecute.size() > 0) { for (int i = 0; i < fixturesToExecute.size(); i++) { runners.add( new TestClassRunnerForFixture(getTestClass().getJavaClass(), fixturesToExecute, i)); } } } else if (parametersList.size() > 0) { for (int i = 0; i < parametersList.size(); i++) { runners.add( new TestClassRunnerForFixture(getTestClass().getJavaClass(), parametersList, i)); } } } else { throw new InitializationError( "Missing Annotation FixtureDefinition for Junit4TestFixtureRunner"); } }
/** * Verifies inTransaction returns the correct response for the various possible states. * * @throws Exception */ public void testInTransaction() throws Exception { AnzoClient client = new AnzoClient(TestConfiguration.getBasicConfiguration()); try { client.begin(Collections.<IPrecondition>emptySet()); assertTrue(client.inTransaction()); client.commit(); assertFalse(client.inTransaction()); client.begin(Collections.<IPrecondition>emptySet()); assertTrue(client.inTransaction()); client.abort(); assertFalse(client.inTransaction()); } finally { client.close(); } }
/** * verify an abort called with no begin is a no-op and does not throw an exception. * * @throws Exception */ public void testNoOpAbort() throws Exception { AnzoClient client = new AnzoClient(TestConfiguration.getBasicConfiguration()); try { client.clear(); boolean exceptionCought = false; try { client.abort(); } catch (Exception e) { exceptionCought = true; } assertFalse(exceptionCought); } finally { client.close(); } }
/** * Tests the {@link LaunchConfiguration#getFileName} method * * @throws Exception */ public void testGetFileName() throws Exception { String filename = config.getFileNameProxy(); assertEquals("The filename should be: 'Test.launch'", "Test.launch", filename); config.setNameProxy("launch"); filename = config.getFileNameProxy(); assertEquals("The filename should be: 'launch.launch'", "launch.launch", filename); config.setNameProxy("launch.foo"); filename = config.getFileNameProxy(); assertEquals("The filename should be: 'launch.foo.launch'", "launch.foo.launch", filename); // reset the name config.setNameProxy("Test"); }
/** * verifies that statements are added to and removed from the transaction proxy correctly for the * following set of operations: * * <pre> * begin transaction * add stmt2 (and verify) * abort transaction * (verify stmt2 is removed) * * * begin transaction * add stmt3 (and verify) * commit transaction * (verify stmt3 still exists) * </pre> * * @throws Exception */ public void testSimpleTransactionIsolation() throws Exception { AnzoClient client = new AnzoClient(TestConfiguration.getBasicConfiguration()); // client.setNotificationEnabled(false); try { ClientGraph replicaGraph = client.getReplicaGraph(TestData.graph1); replicaGraph.add(TestData.stmt1); assertTrue(replicaGraph.contains(TestData.stmt1)); assertFalse(replicaGraph.contains(TestData.stmt2)); assertFalse(replicaGraph.contains(TestData.stmt3)); client.begin(); replicaGraph.add(TestData.stmt2); assertTrue(replicaGraph.contains(TestData.stmt1)); assertTrue(replicaGraph.contains(TestData.stmt2)); assertFalse(replicaGraph.contains(TestData.stmt3)); client.abort(); assertTrue(replicaGraph.contains(TestData.stmt1)); assertFalse(replicaGraph.contains(TestData.stmt2)); assertFalse(replicaGraph.contains(TestData.stmt3)); client.begin(); replicaGraph.add(TestData.stmt3); assertTrue(replicaGraph.contains(TestData.stmt1)); assertFalse(replicaGraph.contains(TestData.stmt2)); assertTrue(replicaGraph.contains(TestData.stmt3)); client.commit(); assertTrue(replicaGraph.contains(TestData.stmt1)); assertFalse(replicaGraph.contains(TestData.stmt2)); assertTrue(replicaGraph.contains(TestData.stmt3)); } finally { client.close(); } }
@Test public void testConvertList() throws Exception { List testList = new ArrayList(); testList.add("value1"); testList.add("value2"); testList.add("value3"); testConfiguration.setXsltParamTestList(testList); Map<String, String> result = converter.convert(testConfiguration); Assert.assertEquals(4, result.size()); String actualListXml = result.get("testList"); String expectedListXml = "<list><value>value1</value><value>value2</value><value>value3</value></list>"; Assert.assertEquals(expectedListXml, actualListXml); }
/** * Tests the {@link LaunchConfiguration#getSimpleName} method * * @throws Exception * @see https://bugs.eclipse.org/bugs/show_bug.cgi?id=332410 */ public void testGetSimpleName() throws Exception { // filenames with the ILaunchConfiguration.LAUNCH_CONFIGURATION_FILE_EXTENSION as an extension String name = config.getSimpleNameProxy("launch.launch"); assertEquals("Did not get expected name: 'launch'", "launch", name); name = config.getSimpleNameProxy("launch.foo.launch"); assertEquals("Did not get expected name: 'launch.foo'", "launch.foo", name); name = config.getSimpleNameProxy("launch.foo.bar.launch"); assertEquals("Did not get expected name: 'launch.foo.bar'", "launch.foo.bar", name); // filenames without the ILaunchConfiguration.LAUNCH_CONFIGURATION_FILE_EXTENSION extension name = config.getSimpleNameProxy("launch"); assertEquals("Did not get expected name: 'launch'", "launch", name); name = config.getSimpleNameProxy("launch.foo"); assertEquals("Did not get expected name: 'launch.foo'", "launch.foo", name); name = config.getSimpleNameProxy("launch.foo.bar"); assertEquals("Did not get expected name: 'launch.foo.bar'", "launch.foo.bar", name); }
@Test public void testGetPropertyAsBooleanMissing() { final Configuration configuration = TestConfiguration.create(); final Optional<Boolean> value = configuration.getPropertyAsBoolean("foo"); Assert.assertFalse(value.isPresent()); }
@Test(expected = IllegalArgumentException.class) public void testGetRequiredAsInvalid() { final Configuration configuration = TestConfiguration.create(); configuration.getRequiredAs(String.class); }
@Test(expected = NoSuchElementException.class) public void testGetRequiredPropertyAsBooleanMissing() { TestConfiguration.create().getRequiredPropertyAsBoolean("foo"); }
@Test public void testGetRequiredPropertyAsBooleanExists() { final Configuration configuration = TestConfiguration.create("foo", "false"); final boolean value = configuration.getRequiredPropertyAsBoolean("foo"); Assert.assertFalse(value); }
@Test public void testGetPropertyAsBooleanWithDefaultMissing() { final Configuration configuration = TestConfiguration.create(); final boolean value = configuration.getPropertyAsBoolean("foo", true); Assert.assertTrue(value); }
@Test public void testGetPropertyAsBooleanWithDefaultExists() { final Configuration configuration = TestConfiguration.create("foo", "false"); final boolean value = configuration.getPropertyAsBoolean("foo", true); Assert.assertFalse(value); }