src_fm_fc_ms_ff
stringlengths 43
86.8k
| target
stringlengths 20
276k
|
|---|---|
BaseHolidays { public LocalDate getLastSundayOf( int year, int month ) { LocalDate dm = new LocalDate( year, month, 31 ); while( true ) { if( dm.getDayOfWeek() == DateTimeConstants.SUNDAY ) return dm; dm = dm.minusDays(1); } } BaseHolidays( String CountryCode ); HolidayInfo create( DateMidnight date, boolean floating, boolean official, String name ); HolidayInfo create( LocalDate date, boolean floating, boolean official, String name ); HolidayInfo create( int year, int month, int day, boolean floating, boolean official, String name ); static LocalDate getEaster( int year ); int getNumberOfCountryCodes(); LocalDate getEuropeanSummerTimeBegin( int year ); LocalDate getEuropeanSummerTimeEnd( int year ); LocalDate getLastSundayOf( int year, int month ); abstract Collection<HolidayInfo> getHolidays(int year); HolidayInfo getHolidayForDay( Calendar date ); HolidayInfo getHolidayForDay( DateMidnight date ); HolidayInfo getHolidayForDay( LocalDate date ); public String CountryCode; } | @Test @Ignore("Not implemented") public void testGetLastSundayOf() { System.out.println("getLastSundayOf"); int year = 0; int month = 0; BaseHolidays instance = null; LocalDate expResult = null; LocalDate result = instance.getLastSundayOf(year, month); assertEquals(expResult, result); fail("The test case is a prototype."); } |
DBString extends DBValue { @Override public DBDataType getDBType() { return DBDataType.DB_TYPE_STRING; } DBString( String name, int max_len ); DBString( String name, String title, int max_len ); DBString( String name, String title, int max_len, boolean is_already_lowercase ); @Override DBDataType getDBType(); @Override void loadFromDB(Object obj); @Override String getValue(); @Override String toString(); @Override void loadFromString(String s); @Override boolean acceptString(String s); @Override DBString getCopy(); @Override void loadFromCopy(Object obj); int getMaxLen(); boolean isEmpty(); boolean isEmptyTrimmed(); } | @Test public void testGetDBType() { System.out.println("getDBType"); for (TestCases test : test_cases) { DBString instance = test.instance; DBDataType expResult = DBDataType.DB_TYPE_STRING; DBDataType result = instance.getDBType(); assertEquals(expResult, result); } } |
StringUtils { static int skip_char_reverse(StringBuilder s, String what, int pos) { while (pos > 0) { char c; c = s.charAt(pos); if (contains(c, what)) { pos--; continue; } break; } return pos; } static int skip_spaces_reverse(StringBuilder s, int pos); static int skip_spaces(StringBuilder s, int pos); static boolean is_space(char c); static List<String> split_str(StringBuilder s, String c); static String strip(StringBuilder s, String what); static String strip_post(StringBuilder s, String what); static String strip_post(String str, String what); static String strip(String s, String what); static void set_defaultAutoLineLenght(int length); static int get_defaultAutoLineLenght(); static String autoLineBreak(String what); static String autoLineBreak(StringBuilder what, int length); static String autoLineBreak(StringBuilder what); static String autoLineBreak(String what, int length); static String formatDouble(double d, int rounding); static String formatDouble(double d); static boolean isYes(String maybe_a_yes_value); @Deprecated static String exceptionToString(Exception ex); static String skipLeadingLines(String sourceString, int lines); static String byteArrayToString(byte[] data); static String addLineNumbers(String text); } | @Test public void testSkip_char_reverse() { System.out.println("skip_char_reverse"); assertEquals(15, StringUtils.skip_char_reverse(new StringBuilder("das ist ein Test"), " ", 15)); assertEquals(10, StringUtils.skip_char_reverse(new StringBuilder("das ist ein Test"), " ", 14)); assertEquals(10, StringUtils.skip_char_reverse(new StringBuilder("das ist ein Test"), " ", 10)); assertEquals(0,StringUtils.skip_char_reverse(null, null, 0)); assertEquals(0,StringUtils.skip_char_reverse(new StringBuilder("x"), null, 0)); assertEquals(0,StringUtils.skip_char_reverse(null, " ", 0)); try { StringUtils.skip_char_reverse(null, null, 10); fail( "nullpointer throws no exception"); } catch( NullPointerException ex ) { } try { StringUtils.skip_char_reverse(new StringBuilder("xyz"), null, 1); fail( "nullpointer throws no exception"); } catch( NullPointerException ex ) { } try { StringUtils.skip_char_reverse(null, " ", 1); fail( "nullpointer throws no exception"); } catch( NullPointerException ex ) { } } |
DBString extends DBValue { @Override public void loadFromDB(Object obj) { value = (String)obj; } DBString( String name, int max_len ); DBString( String name, String title, int max_len ); DBString( String name, String title, int max_len, boolean is_already_lowercase ); @Override DBDataType getDBType(); @Override void loadFromDB(Object obj); @Override String getValue(); @Override String toString(); @Override void loadFromString(String s); @Override boolean acceptString(String s); @Override DBString getCopy(); @Override void loadFromCopy(Object obj); int getMaxLen(); boolean isEmpty(); boolean isEmptyTrimmed(); } | @Test public void testLoadFromDB() { System.out.println("loadFromDB"); for (TestCases test : test_cases) { Object obj = test.db_value; DBString instance = test.instance; instance.loadFromDB(obj); assertEquals(test.exp_value, instance.getValue()); } } |
DBString extends DBValue { @Override public String getValue() { return value; } DBString( String name, int max_len ); DBString( String name, String title, int max_len ); DBString( String name, String title, int max_len, boolean is_already_lowercase ); @Override DBDataType getDBType(); @Override void loadFromDB(Object obj); @Override String getValue(); @Override String toString(); @Override void loadFromString(String s); @Override boolean acceptString(String s); @Override DBString getCopy(); @Override void loadFromCopy(Object obj); int getMaxLen(); boolean isEmpty(); boolean isEmptyTrimmed(); } | @Test public void testGetValue() { System.out.println("getValue"); for (TestCases test : test_cases) { Object obj = test.db_value; DBString instance = test.instance; instance.loadFromDB(obj); assertEquals(test.exp_value, instance.getValue()); } } |
DBString extends DBValue { @Override public String toString() { return value; } DBString( String name, int max_len ); DBString( String name, String title, int max_len ); DBString( String name, String title, int max_len, boolean is_already_lowercase ); @Override DBDataType getDBType(); @Override void loadFromDB(Object obj); @Override String getValue(); @Override String toString(); @Override void loadFromString(String s); @Override boolean acceptString(String s); @Override DBString getCopy(); @Override void loadFromCopy(Object obj); int getMaxLen(); boolean isEmpty(); boolean isEmptyTrimmed(); } | @Test public void testToString() { System.out.println("toString"); for (TestCases test : test_cases) { DBString instance = test.instance; String expResult = test.exp_value; String result = instance.toString(); assertEquals(expResult, result); } } |
DBString extends DBValue { @Override public void loadFromString(String s) { value = s; } DBString( String name, int max_len ); DBString( String name, String title, int max_len ); DBString( String name, String title, int max_len, boolean is_already_lowercase ); @Override DBDataType getDBType(); @Override void loadFromDB(Object obj); @Override String getValue(); @Override String toString(); @Override void loadFromString(String s); @Override boolean acceptString(String s); @Override DBString getCopy(); @Override void loadFromCopy(Object obj); int getMaxLen(); boolean isEmpty(); boolean isEmptyTrimmed(); } | @Test public void testLoadFromString() { System.out.println("loadFromString"); for (TestCases test : test_cases) { String obj = test.db_value; DBString instance = test.instance; instance.loadFromString(obj); assertEquals(test.exp_value, instance.getValue()); } } |
DBString extends DBValue { @Override public boolean acceptString(String s) { if( s.length() > max_len ) return false; return true; } DBString( String name, int max_len ); DBString( String name, String title, int max_len ); DBString( String name, String title, int max_len, boolean is_already_lowercase ); @Override DBDataType getDBType(); @Override void loadFromDB(Object obj); @Override String getValue(); @Override String toString(); @Override void loadFromString(String s); @Override boolean acceptString(String s); @Override DBString getCopy(); @Override void loadFromCopy(Object obj); int getMaxLen(); boolean isEmpty(); boolean isEmptyTrimmed(); } | @Test public void testAcceptString() { System.out.println("acceptString"); ArrayList<SimpleEntry<String,Boolean>> test_strings = new ArrayList(); test_strings.add(new SimpleEntry<>(NORMAL_STRING, true)); test_strings.add(new SimpleEntry<>(LONG_STRING, false)); for (TestCases test : test_cases) { for( SimpleEntry<String,Boolean> e : test_strings ) { String s = e.getKey(); DBString instance = test.instance; boolean expResult = e.getValue(); boolean result = instance.acceptString(s); assertEquals(expResult, result); } } } |
DBString extends DBValue { @Override public DBString getCopy() { DBString s = new DBString( name, title, max_len ); s.value = value; return s; } DBString( String name, int max_len ); DBString( String name, String title, int max_len ); DBString( String name, String title, int max_len, boolean is_already_lowercase ); @Override DBDataType getDBType(); @Override void loadFromDB(Object obj); @Override String getValue(); @Override String toString(); @Override void loadFromString(String s); @Override boolean acceptString(String s); @Override DBString getCopy(); @Override void loadFromCopy(Object obj); int getMaxLen(); boolean isEmpty(); boolean isEmptyTrimmed(); } | @Test public void testGetCopy() { System.out.println("getCopy"); for (TestCases test : test_cases) { DBString instance = test.instance; DBString result = instance.getCopy(); assertNotSame(result, instance); } } |
DBString extends DBValue { @Override public void loadFromCopy(Object obj) { value = (String)obj; } DBString( String name, int max_len ); DBString( String name, String title, int max_len ); DBString( String name, String title, int max_len, boolean is_already_lowercase ); @Override DBDataType getDBType(); @Override void loadFromDB(Object obj); @Override String getValue(); @Override String toString(); @Override void loadFromString(String s); @Override boolean acceptString(String s); @Override DBString getCopy(); @Override void loadFromCopy(Object obj); int getMaxLen(); boolean isEmpty(); boolean isEmptyTrimmed(); } | @Test public void testLoadFromCopy() { System.out.println("loadFromCopy"); for (TestCases test : test_cases) { Object obj = NORMAL_STRING; DBString instance = test.instance; instance.loadFromCopy(obj); assertEquals(obj, instance.value); } } |
DBString extends DBValue { public int getMaxLen() { return max_len; } DBString( String name, int max_len ); DBString( String name, String title, int max_len ); DBString( String name, String title, int max_len, boolean is_already_lowercase ); @Override DBDataType getDBType(); @Override void loadFromDB(Object obj); @Override String getValue(); @Override String toString(); @Override void loadFromString(String s); @Override boolean acceptString(String s); @Override DBString getCopy(); @Override void loadFromCopy(Object obj); int getMaxLen(); boolean isEmpty(); boolean isEmptyTrimmed(); } | @Test public void testGetMaxLen() { System.out.println("getMaxLen"); for (TestCases test : test_cases) { DBString instance = test.instance; int result = instance.getMaxLen(); assertEquals(MAX_LEN, result); } } |
DBString extends DBValue { public boolean isEmpty() { return value.isEmpty(); } DBString( String name, int max_len ); DBString( String name, String title, int max_len ); DBString( String name, String title, int max_len, boolean is_already_lowercase ); @Override DBDataType getDBType(); @Override void loadFromDB(Object obj); @Override String getValue(); @Override String toString(); @Override void loadFromString(String s); @Override boolean acceptString(String s); @Override DBString getCopy(); @Override void loadFromCopy(Object obj); int getMaxLen(); boolean isEmpty(); boolean isEmptyTrimmed(); } | @Test public void testIsEmpty() { System.out.println("isEmpty"); for (TestCases test : test_cases) { DBString instance = test.instance; boolean expResult = false; boolean result = instance.isEmpty(); assertEquals(expResult, result); } } |
DBString extends DBValue { public boolean isEmptyTrimmed() { return value.trim().isEmpty(); } DBString( String name, int max_len ); DBString( String name, String title, int max_len ); DBString( String name, String title, int max_len, boolean is_already_lowercase ); @Override DBDataType getDBType(); @Override void loadFromDB(Object obj); @Override String getValue(); @Override String toString(); @Override void loadFromString(String s); @Override boolean acceptString(String s); @Override DBString getCopy(); @Override void loadFromCopy(Object obj); int getMaxLen(); boolean isEmpty(); boolean isEmptyTrimmed(); } | @Test @Ignore("Not implemented") public void testIsEmptyTrimmed() { System.out.println("isEmptyTrimmed"); DBString instance = null; boolean expResult = false; boolean result = instance.isEmptyTrimmed(); assertEquals(expResult, result); fail("The test case is a prototype."); } |
StringUtils { public static int skip_spaces_reverse(StringBuilder s, int pos) { return skip_char_reverse(s, " \t\n\r", pos); } static int skip_spaces_reverse(StringBuilder s, int pos); static int skip_spaces(StringBuilder s, int pos); static boolean is_space(char c); static List<String> split_str(StringBuilder s, String c); static String strip(StringBuilder s, String what); static String strip_post(StringBuilder s, String what); static String strip_post(String str, String what); static String strip(String s, String what); static void set_defaultAutoLineLenght(int length); static int get_defaultAutoLineLenght(); static String autoLineBreak(String what); static String autoLineBreak(StringBuilder what, int length); static String autoLineBreak(StringBuilder what); static String autoLineBreak(String what, int length); static String formatDouble(double d, int rounding); static String formatDouble(double d); static boolean isYes(String maybe_a_yes_value); @Deprecated static String exceptionToString(Exception ex); static String skipLeadingLines(String sourceString, int lines); static String byteArrayToString(byte[] data); static String addLineNumbers(String text); } | @Test public void testSkip_spaces_reverse() { System.out.println("skip_spaces_reverse"); assertEquals(15, StringUtils.skip_spaces_reverse(new StringBuilder("das ist ein Test"), 15)); assertEquals(10, StringUtils.skip_spaces_reverse(new StringBuilder("das ist ein \t Test"), 14)); assertEquals(10, StringUtils.skip_spaces_reverse(new StringBuilder("das ist ein Test"), 10)); try { StringUtils.skip_spaces_reverse(null, 1 ); fail( "nullpointer throws no exception"); } catch( NullPointerException ex ) { } } |
StringUtils { public static int skip_spaces(StringBuilder s, int pos) { return skip_char(s, " \t\n\r", pos); } static int skip_spaces_reverse(StringBuilder s, int pos); static int skip_spaces(StringBuilder s, int pos); static boolean is_space(char c); static List<String> split_str(StringBuilder s, String c); static String strip(StringBuilder s, String what); static String strip_post(StringBuilder s, String what); static String strip_post(String str, String what); static String strip(String s, String what); static void set_defaultAutoLineLenght(int length); static int get_defaultAutoLineLenght(); static String autoLineBreak(String what); static String autoLineBreak(StringBuilder what, int length); static String autoLineBreak(StringBuilder what); static String autoLineBreak(String what, int length); static String formatDouble(double d, int rounding); static String formatDouble(double d); static boolean isYes(String maybe_a_yes_value); @Deprecated static String exceptionToString(Exception ex); static String skipLeadingLines(String sourceString, int lines); static String byteArrayToString(byte[] data); static String addLineNumbers(String text); } | @Test public void testSkip_spaces() { System.out.println("skip_spaces"); assertEquals(12, StringUtils.skip_spaces(new StringBuilder( "das ist ein Text"), 7)); assertEquals(2, StringUtils.skip_spaces(new StringBuilder( "das ist ein Text"), 2)); assertEquals(4, StringUtils.skip_spaces(new StringBuilder( "das ist ein Text"), 4)); assertEquals(4, StringUtils.skip_spaces(new StringBuilder( "das ist ein Text"), 3)); try { StringUtils.skip_spaces(null, 1 ); fail( "nullpointer throws no exception"); } catch( NullPointerException ex ) { } } |
StringUtils { public static boolean is_space(char c) { if (c == ' ' || c == '\t' || c == '\n' || c == '\r') { return true; } return false; } static int skip_spaces_reverse(StringBuilder s, int pos); static int skip_spaces(StringBuilder s, int pos); static boolean is_space(char c); static List<String> split_str(StringBuilder s, String c); static String strip(StringBuilder s, String what); static String strip_post(StringBuilder s, String what); static String strip_post(String str, String what); static String strip(String s, String what); static void set_defaultAutoLineLenght(int length); static int get_defaultAutoLineLenght(); static String autoLineBreak(String what); static String autoLineBreak(StringBuilder what, int length); static String autoLineBreak(StringBuilder what); static String autoLineBreak(String what, int length); static String formatDouble(double d, int rounding); static String formatDouble(double d); static boolean isYes(String maybe_a_yes_value); @Deprecated static String exceptionToString(Exception ex); static String skipLeadingLines(String sourceString, int lines); static String byteArrayToString(byte[] data); static String addLineNumbers(String text); } | @Test public void testIs_space() { System.out.println("is_space"); assertTrue(StringUtils.is_space(' ')); assertTrue(StringUtils.is_space('\t')); assertTrue(StringUtils.is_space('\r')); assertTrue(StringUtils.is_space('\n')); assertFalse(StringUtils.is_space('\0')); assertFalse(StringUtils.is_space('x')); } |
StringUtils { public static List<String> split_str(StringBuilder s, String c) { List<String> res = new ArrayList<>(); int start = 0; do { int pos = s.indexOf(c, start); if (pos < 0) { res.add(s.substring(start)); break; } res.add(s.substring(start, pos)); start = pos + 1; } while (start > 0); return res; } static int skip_spaces_reverse(StringBuilder s, int pos); static int skip_spaces(StringBuilder s, int pos); static boolean is_space(char c); static List<String> split_str(StringBuilder s, String c); static String strip(StringBuilder s, String what); static String strip_post(StringBuilder s, String what); static String strip_post(String str, String what); static String strip(String s, String what); static void set_defaultAutoLineLenght(int length); static int get_defaultAutoLineLenght(); static String autoLineBreak(String what); static String autoLineBreak(StringBuilder what, int length); static String autoLineBreak(StringBuilder what); static String autoLineBreak(String what, int length); static String formatDouble(double d, int rounding); static String formatDouble(double d); static boolean isYes(String maybe_a_yes_value); @Deprecated static String exceptionToString(Exception ex); static String skipLeadingLines(String sourceString, int lines); static String byteArrayToString(byte[] data); static String addLineNumbers(String text); } | @Test public void testSplit_str() { System.out.println("split_str"); String[] testArr = { "hallo", "das", "ist", "", "ein", "" , "", "test", "" }; StringBuilder joined_string = new StringBuilder(); for( String str: testArr ) { if( joined_string.length() > 0 ) { joined_string.append('|'); } joined_string.append(str); } List<String> split_str = StringUtils.split_str(joined_string, "|"); assertEquals(testArr.length, split_str.size()); for( int i = 0; i < testArr.length; i++ ) { if( !testArr[i].equals(split_str.get(i)) ) { fail( String.format("Target: '%s' Index %d '%s' != '%s'", joined_string, i, testArr[i],split_str.get(i) ) ); } } } |
StringUtils { public static String strip_post(StringBuilder s, String what) { int end = skip_char_reverse(s, what, s.length() - 1); return s.substring(0, end + 1); } static int skip_spaces_reverse(StringBuilder s, int pos); static int skip_spaces(StringBuilder s, int pos); static boolean is_space(char c); static List<String> split_str(StringBuilder s, String c); static String strip(StringBuilder s, String what); static String strip_post(StringBuilder s, String what); static String strip_post(String str, String what); static String strip(String s, String what); static void set_defaultAutoLineLenght(int length); static int get_defaultAutoLineLenght(); static String autoLineBreak(String what); static String autoLineBreak(StringBuilder what, int length); static String autoLineBreak(StringBuilder what); static String autoLineBreak(String what, int length); static String formatDouble(double d, int rounding); static String formatDouble(double d); static boolean isYes(String maybe_a_yes_value); @Deprecated static String exceptionToString(Exception ex); static String skipLeadingLines(String sourceString, int lines); static String byteArrayToString(byte[] data); static String addLineNumbers(String text); } | @Test public void testStrip_post_StringBuilder_String() { System.out.println("strip_post"); try { StringUtils.strip_post( (StringBuilder)null, "" ); fail( "nullpointer throws no exception"); } catch( NullPointerException ex ) { } try { StringUtils.strip_post( (StringBuilder)null, null ); fail( "nullpointer throws no exception"); } catch( NullPointerException ex ) { } try { StringUtils.strip_post( new StringBuilder("xxxx"), null ); fail( "nullpointer throws no exception"); } catch( NullPointerException ex ) { } assertEquals("xyz", StringUtils.strip_post(new StringBuilder("xyz"), "")); assertEquals(" xyz", StringUtils.strip_post(new StringBuilder(" xyz "), " ")); assertEquals(" xyz", StringUtils.strip_post(new StringBuilder(" xyz"), " ")); assertEquals(" xyz\t", StringUtils.strip_post(new StringBuilder(" xyz\t"), " ")); assertEquals(" xyz\t", StringUtils.strip_post(new StringBuilder(" xyz\t "), " ")); assertEquals(" xy z", StringUtils.strip_post(new StringBuilder(" xy z\t "), " \t")); assertEquals(" xy z", StringUtils.strip_post(new StringBuilder(" xy z\t \t"), " \t")); assertEquals(" xy z", StringUtils.strip_post(new StringBuilder(" xy z\t \n"), " \t\n")); }
@Test public void testStrip_post_String_String() { System.out.println("strip_post"); try { StringUtils.strip_post( (String)null, "" ); fail( "nullpointer throws no exception"); } catch( NullPointerException ex ) { } try { StringUtils.strip_post( (String)null, null ); fail( "nullpointer throws no exception"); } catch( NullPointerException ex ) { } try { StringUtils.strip_post( "xxxx", null ); fail( "nullpointer throws no exception"); } catch( NullPointerException ex ) { } assertEquals("xyz", StringUtils.strip_post("xyz", "")); assertEquals(" xyz", StringUtils.strip_post(" xyz ", " ")); assertEquals(" xyz", StringUtils.strip_post(" xyz", " ")); assertEquals(" xyz\t", StringUtils.strip_post(" xyz\t", " ")); assertEquals(" xyz\t", StringUtils.strip_post(" xyz\t ", " ")); assertEquals(" xy z", StringUtils.strip_post(" xy z\t ", " \t")); assertEquals(" xy z", StringUtils.strip_post(" xy z\t \t", " \t")); assertEquals(" xy z", StringUtils.strip_post(" xy z\t \n", " \t\n")); } |
NetworkStatusPresenter implements NetworkStatusContract.Presenter { @Override public void getNodes() { stopNodeRefresh(); startNodeRefresh(); } NetworkStatusPresenter(NetworkStatusContract.View view, Feature6LoWPANProtocol centralNode); @Override void startNodeRefresh(); @Override void stopNodeRefresh(); @Override void getNodes(); @Override void onNodeSelected(SensorNode node); } | @Test public void toGetTheNodeListTheFeatureIsCalled(){ mPresenter.getNodes(); verify(mFeature).getNetworkNodeList(any(Feature6LoWPANProtocol.NetworkNodeListCallback.class)); }
@Test public void whenTheNodeListCallbackIsCalledTheViewIsUpdated(){ mPresenter.getNodes(); ArgumentCaptor<Feature6LoWPANProtocol.NetworkNodeListCallback> callback = ArgumentCaptor.forClass(Feature6LoWPANProtocol.NetworkNodeListCallback.class); verify(mFeature).getNetworkNodeList(callback.capture()); callback.getValue().onComplete(SENSOR_NODES); verify(mView).showNodes(SENSOR_NODES); } |
Feature6LoWPANProtocol extends Feature { public boolean getNetworkNodeList(NetworkNodeListCallback callback) { Log.d("6lowpan","getNetworkNodeList: "+mRequestTimeout); if(mRequestTimeout !=null) return false; mNodeListCallback = callback; getParentNode().enableNotification(this); mNetworkResponse = new NetworkResponse(); NetworkRequest cmd = new NetworkRequest.Builder() .withCommand(GET_NODE_LIST_CMD_ID) .build(); mRequestTimeout = new ResponseManager(() -> { if(mNodeListCallback!=null) { mNodeListCallback.onRequestTimeOut(); mNodeListCallback = null; } }); writeData(cmd.getByte()); return true; } Feature6LoWPANProtocol(Node n); boolean getNetworkNodeList(NetworkNodeListCallback callback); void abortRequest(); boolean getNodeStatus(SensorNode node, NodeStatusCallback callback); boolean getNetworkTopology(NetworkTopologyCallback callback); boolean updateLedDimming(NetworkAddress address,byte dimmingValue,LedStatusChangeCallback callback); void updateLedDimming(SensorNode node,LedStatusChangeCallback callback); @VisibleForTesting
static final short GET_NODE_LIST_CMD_ID; @VisibleForTesting
static final short GET_NODE_STATUS_CMD_ID; @VisibleForTesting
static final short CHANGE_ACUTATOR_STATUS_CMD_ID; @VisibleForTesting
static final short GET_NETWORK_TOPOLOGY_CMD_ID; } | @Test public void whenTheNodeReceiveAllTheDataDisableTheNotificaiton(){ mFeature.getNetworkNodeList(mNodeListCallback); mFeature.receiveData(GET_NODE_LIST_RESPONSE); verify(mNode).disableNotification(mFeature); }
@Test public void getNetworkNodeListSendCorrectMessage(){ mFeature.getNetworkNodeList(mNodeListCallback); NetworkRequest cmd = new NetworkRequest(mFeature.getLastWriteData()); Assert.assertEquals(GET_NODE_LIST_CMD_ID,cmd.getCommandId()); Assert.assertEquals(6,cmd.getLength()); }
@Test public void getNetworkNodeListEnableNotification(){ mFeature.getNetworkNodeList(mNodeListCallback); verify(mNode).enableNotification(mFeature); }
@Test public void whenTheNodeListReceiveAllTheDataTheCallbackIsCalled(){ mFeature.getNetworkNodeList(mNodeListCallback); mFeature.receiveData(GET_NODE_LIST_RESPONSE); ArgumentCaptor<List> parseResponseCapt = ArgumentCaptor.forClass(List.class); verify(mNodeListCallback).onComplete(parseResponseCapt.capture()); List<SensorNode> nodes = (List<SensorNode>) parseResponseCapt.getValue(); Assert.assertEquals(1, nodes.size()); Assert.assertTrue( Arrays.equals(Arrays.copyOfRange(GET_NODE_LIST_RESPONSE, GET_NODE_LIST_RESPONSE.length-8, GET_NODE_LIST_RESPONSE.length), nodes.get(0).getAddress().getBytes())); } |
Feature6LoWPANProtocol extends Feature { public boolean getNodeStatus(SensorNode node, NodeStatusCallback callback){ Log.d("6lowpan","getNodeStatus: "+mRequestTimeout); if(mRequestTimeout !=null) return false; mNodeStatusCallback = new PrivateNodeStatusCallback(node,callback); getParentNode().enableNotification(this); mNetworkResponse = new NetworkResponse(); NetworkRequest cmd = new NetworkRequest.Builder() .withCommand(GET_NODE_STATUS_CMD_ID) .withPayload(node.getAddress().getBytes()) .build(); mRequestTimeout = new ResponseManager(() -> { if(mNodeListCallback!=null) { callback.onRequestFail(node); mNodeListCallback = null; } }); writeData(cmd.getByte()); return true; } Feature6LoWPANProtocol(Node n); boolean getNetworkNodeList(NetworkNodeListCallback callback); void abortRequest(); boolean getNodeStatus(SensorNode node, NodeStatusCallback callback); boolean getNetworkTopology(NetworkTopologyCallback callback); boolean updateLedDimming(NetworkAddress address,byte dimmingValue,LedStatusChangeCallback callback); void updateLedDimming(SensorNode node,LedStatusChangeCallback callback); @VisibleForTesting
static final short GET_NODE_LIST_CMD_ID; @VisibleForTesting
static final short GET_NODE_STATUS_CMD_ID; @VisibleForTesting
static final short CHANGE_ACUTATOR_STATUS_CMD_ID; @VisibleForTesting
static final short GET_NETWORK_TOPOLOGY_CMD_ID; } | @Test public void getNodeStatusListSendCorrectMessage(){ NetworkAddress address = new NetworkAddress(new byte[]{1,2,3,4,5,6,7,9}); SensorNode node = new SensorNode(address); mFeature.getNodeStatus(node,mNodeStatusCallback); NetworkRequest cmd = new NetworkRequest(mFeature.getLastWriteData()); Assert.assertEquals(GET_NODE_STATUS_CMD_ID,cmd.getCommandId()); Assert.assertEquals(6+8,cmd.getLength()); Assert.assertTrue(Arrays.equals(address.getBytes(),cmd.getPayload())); }
@Test public void whenTheNodeStatusReceiveAllTheDataTheCallbackIsCalled(){ NetworkAddress address = new NetworkAddress(new byte[]{1,2,3,4,5,6,0x66,0x77}); SensorNode node = mock(SensorNode.class); when(node.getAddress()).thenReturn(address); mFeature.getNodeStatus(node,mNodeStatusCallback); mFeature.receiveData(GET_NODE_STATUS_REPONSE); verify(mNodeStatusCallback).onNodeStatusUpdate(eq(node)); checkAllTheNodePropriertiesAreUpdated(node); }
@Test public void whenTheNodeStatusReceiveIfTheNodeIdIsDifferentTheErrorCallbackIsCalled(){ NetworkAddress address = new NetworkAddress(new byte[]{1,2,3,4,5,6,0x78,0x66}); SensorNode node = mock(SensorNode.class); when(node.getAddress()).thenReturn(address); mFeature.getNodeStatus(node,mNodeStatusCallback); mFeature.receiveData(GET_NODE_STATUS_REPONSE); verify(mNodeStatusCallback).onRequestFail(eq(node)); } |
Feature6LoWPANProtocol extends Feature { public boolean updateLedDimming(NetworkAddress address,byte dimmingValue,LedStatusChangeCallback callback) { Log.d("6lowpan","update dimming: "+mRequestTimeout); if(mRequestTimeout !=null) return false; byte payload[] = new byte[10]; System.arraycopy(address.getBytes(),0,payload,0,8); payload[8]=0x10; payload[9]=dimmingValue; mNodeLedStatusCallback = new PrivateLedStatusCallback(address,callback); getParentNode().enableNotification(this); mNetworkResponse = new NetworkResponse(); NetworkRequest cmd = new NetworkRequest.Builder() .withCommand(CHANGE_ACUTATOR_STATUS_CMD_ID) .withPayload(payload) .build(); mRequestTimeout = new ResponseManager(() -> { if(mNodeLedStatusCallback!=null) { callback.onRequestFail(address); mNodeLedStatusCallback=null; } }); writeData(cmd.getByte()); return true; } Feature6LoWPANProtocol(Node n); boolean getNetworkNodeList(NetworkNodeListCallback callback); void abortRequest(); boolean getNodeStatus(SensorNode node, NodeStatusCallback callback); boolean getNetworkTopology(NetworkTopologyCallback callback); boolean updateLedDimming(NetworkAddress address,byte dimmingValue,LedStatusChangeCallback callback); void updateLedDimming(SensorNode node,LedStatusChangeCallback callback); @VisibleForTesting
static final short GET_NODE_LIST_CMD_ID; @VisibleForTesting
static final short GET_NODE_STATUS_CMD_ID; @VisibleForTesting
static final short CHANGE_ACUTATOR_STATUS_CMD_ID; @VisibleForTesting
static final short GET_NETWORK_TOPOLOGY_CMD_ID; } | @Test public void updateLedDimmingSendCorrectCommand(){ byte address[] = new byte[]{1,2,3,4,5,6,7,9}; byte ledDimmingValue = 50; byte requestPayload[] = new byte[]{ 1,2,3,4,5,6,7,9, 0x10, ledDimmingValue }; SensorNode node = new SensorNode(new NetworkAddress(address)); node.setLedDimming(ledDimmingValue); mFeature.updateLedDimming(node); NetworkRequest cmd = new NetworkRequest(mFeature.getLastWriteData()); Assert.assertEquals(CHANGE_ACUTATOR_STATUS_CMD_ID,cmd.getCommandId()); Assert.assertEquals(6+8+2,cmd.getLength()); Assert.assertTrue(Arrays.equals(requestPayload,cmd.getPayload())); } |
GetSensorNodeStatusParser { public static @NonNull SensorData parse(byte[] rawData){ if(rawData.length > MAX_MESSAGE_SIZE){ throw new IllegalArgumentException("The rawData must have "+ MAX_MESSAGE_SIZE +" bytes, found: "+rawData.length); } SensorData data = new SensorData(); int offset = 0; data.setShortSensorNodeId(NumberConversion.BigEndian.bytesToInt16(rawData,offset)); offset+=2; while (offset!=rawData.length){ byte sensorId = rawData[offset++]; if(sensorId == SensorId.Temperature.getSensorId()){ data.setTemperature(NumberConversion.LittleEndian.bytesToInt16(rawData,offset)/10.0f); offset+=2; }else if(sensorId == SensorId.Pressure.getSensorId()){ data.setPressure((NumberConversion.LittleEndian.bytesToInt16(rawData,offset)*16.0f)); offset+=2; }else if(sensorId == SensorId.Humidity.getSensorId()){ data.setHumidity(NumberConversion.LittleEndian.bytesToInt16(rawData,offset)); offset+=2; }else if(sensorId == SensorId.Acceleration.getSensorId()) { data.setAccX(NumberConversion.LittleEndian.bytesToInt16(rawData, offset)); offset += 2; data.setAccY(NumberConversion.LittleEndian.bytesToInt16(rawData, offset)); offset += 2; data.setAccZ(NumberConversion.LittleEndian.bytesToInt16(rawData, offset)); offset += 2; }else if(sensorId == SensorId.Magnetometer.getSensorId()) { data.setMagX(NumberConversion.LittleEndian.bytesToInt16(rawData, offset)); offset += 2; data.setMagY(NumberConversion.LittleEndian.bytesToInt16(rawData, offset)); offset += 2; data.setMagZ(NumberConversion.LittleEndian.bytesToInt16(rawData, offset)); offset += 2; }else if(sensorId == SensorId.Gyroscope.getSensorId()) { data.setGyroX(NumberConversion.LittleEndian.bytesToInt16(rawData, offset)/10.0f); offset += 2; data.setGyroY(NumberConversion.LittleEndian.bytesToInt16(rawData, offset)/10.0f); offset += 2; data.setGyroZ(NumberConversion.LittleEndian.bytesToInt16(rawData, offset)/10.0f); offset += 2; } } return data; } static @NonNull SensorData parse(byte[] rawData); } | @Test(expected = IllegalArgumentException.class) public void anExceptionIsThrowIfPayloadIsBiggerThan42bytes(){ GetSensorNodeStatusParser.parse(new byte[43]); }
@Test public void extractTheNodeIdValue(){ SensorData sensorData = GetSensorNodeStatusParser.parse(mRawData); assertEquals(NODE_ID,sensorData.getShortSensorNodeId()); }
@Test public void extractTheTemperatureValue(){ SensorData sensorData = GetSensorNodeStatusParser.parse(mRawData); assertEquals(TEMPERATURE,sensorData.getTemperature()); }
@Test public void extractThePressureValue(){ SensorData sensorData = GetSensorNodeStatusParser.parse(mRawData); assertEquals(PRESSURE,sensorData.getPressure()); }
@Test public void extractTheHumidityValue(){ SensorData sensorData = GetSensorNodeStatusParser.parse(mRawData); assertEquals(HUMIDITY,sensorData.getHumidity()); }
@Test public void extractTheAcceleromiterValue(){ SensorData sensorData = GetSensorNodeStatusParser.parse(mRawData); assertEquals(ACC[0],sensorData.getAccX()); assertEquals(ACC[1],sensorData.getAccY()); assertEquals(ACC[2],sensorData.getAccZ()); }
@Test public void extractTheGyroscopeValue(){ SensorData sensorData = GetSensorNodeStatusParser.parse(mRawData); assertEquals(GYRO[0],sensorData.getGyroX()); assertEquals(GYRO[1],sensorData.getGyroY()); assertEquals(GYRO[2],sensorData.getGyroZ()); }
@Test public void extractTheMagnetometerValue(){ SensorData sensorData = GetSensorNodeStatusParser.parse(mRawData); assertEquals(MAG[0],sensorData.getMagX()); assertEquals(MAG[1],sensorData.getMagY()); assertEquals(MAG[2],sensorData.getMagZ()); } |
GetSensorNodeListParser { public static @Nullable List<SensorNode> parse(byte[] responsePayload){ int nNodes = responsePayload[0]; if(responsePayload.length!=nNodes*NetworkAddress.ADDRESS_LENGTH+1) return null; ArrayList<SensorNode> nodes = new ArrayList<>(nNodes); for(int i=0;i<nNodes;i++){ byte rawAddress[] = new byte[NetworkAddress.ADDRESS_LENGTH]; int startOffset = 1+i*NetworkAddress.ADDRESS_LENGTH; System.arraycopy(responsePayload,startOffset,rawAddress,0, NetworkAddress.ADDRESS_LENGTH); nodes.add(new SensorNode(rawAddress)); } return nodes; } static @Nullable List<SensorNode> parse(byte[] responsePayload); } | @Test public void IfThePayloadHasWrongSizeNullIsReturned_payloadTooSmall(){ Assert.assertNull(GetSensorNodeListParser.parse(new byte[]{1})); }
@Test public void IfThePayloadHasWrongSizeNullIsReturned_payloadTooBig(){ Assert.assertNull(GetSensorNodeListParser.parse(new byte[]{1,0,0,0,0,0,0,0,0,0})); }
@Test public void parseASingleNodeNetwork(){ byte payload[] = new byte[9]; payload[0]=1; System.arraycopy(ADDRESS1,0,payload,1,ADDRESS1.length); List<SensorNode> nodes = GetSensorNodeListParser.parse(payload); Assert.assertEquals(1,nodes.size()); Assert.assertTrue(Arrays.equals(ADDRESS1,nodes.get(0).getAddress().getBytes())); }
@Test public void parseADoubleNodeNetwork(){ byte payload[] = new byte[1+2*ADDRESS1.length]; payload[0]=2; System.arraycopy(ADDRESS1,0,payload,1,ADDRESS1.length); System.arraycopy(ADDRESS2,0,payload,1+ADDRESS1.length,ADDRESS1.length); List<SensorNode> nodes = GetSensorNodeListParser.parse(payload); Assert.assertEquals(2,nodes.size()); Assert.assertTrue(Arrays.equals(ADDRESS1,nodes.get(0).getAddress().getBytes())); Assert.assertTrue(Arrays.equals(ADDRESS2,nodes.get(1).getAddress().getBytes())); } |
NetworkResponse { public void append(@NonNull byte[] bytes) { for(byte b : bytes){ mData.add(b); } } void append(@NonNull byte[] bytes); short getTimestamp(); short getCommandId(); short getLength(); boolean isCompleted(); byte[] getPayload(); } | @Test public void theByteAreAppendedToTheResponse(){ mResp.append(new byte[]{1,2,3}); } |
InitializerMessageSource extends AbstractMessageSource implements MutableMessageSource, ApplicationContextAware { public Locale getLocaleFromFileBaseName(String baseName) throws IllegalArgumentException { String[] parts = baseName.split("_"); if (parts.length == 1) { throw new IllegalArgumentException( "'" + baseName + "' is not suffixed with the string representation of a locale."); } String candidate = ""; for (int i = parts.length - 1; i > 0; i--) { candidate = parts[i] + (candidate == "" ? "" : "_") + candidate; Locale locale; try { locale = LocaleUtils.toLocale(candidate); } catch (IllegalArgumentException e) { continue; } return locale; } throw new IllegalArgumentException( "No valid locale could be inferred from the following file base name: '" + baseName + "'."); } Map<File, Locale> getMessagePropertiesMap(); @Override void setApplicationContext(ApplicationContext context); synchronized Map<Locale, PresentationMessageMap> getCachedMessages(); Locale getLocaleFromFileBaseName(String baseName); void addMessageProperties(String dirPath); @Override Collection<Locale> getLocales(); @SuppressWarnings("deprecation") void publishProperties(Properties props, String locale, String namespace, String name, String version); @Override Collection<PresentationMessage> getPresentations(); @Override Collection<PresentationMessage> getPresentationsInLocale(Locale locale); @Override void addPresentation(PresentationMessage message); @Override PresentationMessage getPresentation(String code, Locale locale); @Override void removePresentation(PresentationMessage message); @Override void merge(MutableMessageSource fromSource, boolean overwrite); static Properties loadPropertiesFromFile(File propFile); } | @Test public void getLocaleFromFileBaseName_shouldInferValidLocale() { InitializerMessageSource src = new InitializerMessageSource(); Assert.assertEquals(Locale.FRENCH, src.getLocaleFromFileBaseName("basename_fr")); Assert.assertEquals(Locale.FRENCH, src.getLocaleFromFileBaseName("my_base_name_fr")); Assert.assertEquals(Locale.FRENCH, src.getLocaleFromFileBaseName("_my_base_name_fr")); Assert.assertEquals(Locale.FRENCH, src.getLocaleFromFileBaseName("_my_base_name_fr_")); Assert.assertEquals(new Locale("fr", "FR"), src.getLocaleFromFileBaseName("my_base_name_fr_FR")); Assert.assertEquals(new Locale("fr", "BE"), src.getLocaleFromFileBaseName("my_base_name_fr_BE")); }
@Test public void getLocaleFromFileBaseName_shouldThrowIfNoValidLocaleAsSuffixToFileBaseName() { InitializerMessageSource src = new InitializerMessageSource(); try { src.getLocaleFromFileBaseName("my_base_name"); } catch (IllegalArgumentException e) { Assert.assertTrue(e.getMessage() .equals("No valid locale could be inferred from the following file base name: 'my_base_name'.")); } }
@Test public void getLocaleFromFileBaseName_shouldThrowIfNoSuffixInFileBaseName() { InitializerMessageSource src = new InitializerMessageSource(); try { src.getLocaleFromFileBaseName("my-base-name"); } catch (IllegalArgumentException e) { Assert.assertTrue( e.getMessage().equals("'my-base-name' is not suffixed with the string representation of a locale.")); } } |
NestedConceptLineProcessor extends ConceptLineProcessor { public Concept fill(Concept concept, CsvLine line) throws IllegalArgumentException { if (!CollectionUtils.isEmpty(concept.getAnswers())) { concept.getAnswers().clear(); } String childrenStr; childrenStr = line.get(HEADER_ANSWERS); if (!StringUtils.isEmpty(childrenStr)) { for (Concept child : listParser.parseList(childrenStr)) { concept.addAnswer(new ConceptAnswer(child)); } } if (!CollectionUtils.isEmpty(concept.getConceptSets())) { concept.getConceptSets().clear(); concept.setSet(false); } childrenStr = line.get(HEADER_MEMBERS); if (!StringUtils.isEmpty(childrenStr)) { for (Concept child : listParser.parseList(childrenStr)) { concept.addSetMember(child); } concept.setSet(true); } return concept; } @Autowired NestedConceptLineProcessor(@Qualifier("conceptService") ConceptService conceptService,
ConceptListParser listParser); Concept fill(Concept concept, CsvLine line); } | @Test public void fill_shouldHandleNoChildren() { String[] headerLine = { "Answers", "Members" }; String[] line = { null, null }; NestedConceptLineProcessor p = new NestedConceptLineProcessor(cs, new ConceptListParser(cs)); Concept c = p.fill(new Concept(), new CsvLine(headerLine, line)); Assert.assertFalse(c.getSet()); Assert.assertEquals(0, c.getSetMembers().size()); Assert.assertEquals(0, c.getAnswers().size()); }
@Test public void fill_shouldParseAnswers() { String[] headerLine = { "Answers", "Members" }; String[] line = { "cambodia:123; cambodia:456", null }; NestedConceptLineProcessor p = new NestedConceptLineProcessor(cs, new ConceptListParser(cs)); Concept c = p.fill(new Concept(), new CsvLine(headerLine, line)); Assert.assertFalse(c.getSet()); Collection<ConceptAnswer> answers = c.getAnswers(); Assert.assertEquals(2, answers.size()); Set<String> uuids = new HashSet<String>(); for (ConceptAnswer a : answers) { uuids.add(a.getAnswerConcept().getUuid()); } Assert.assertTrue(uuids.contains("cambodia:123")); Assert.assertTrue(uuids.contains("cambodia:456")); }
@Test public void fill_shouldParseSetMembers() { String[] headerLine = { "Answers", "Members" }; String[] line = { null, "cambodia:123; cambodia:456" }; NestedConceptLineProcessor p = new NestedConceptLineProcessor(cs, new ConceptListParser(cs)); Concept c = p.fill(new Concept(), new CsvLine(headerLine, line)); Assert.assertTrue(c.getSet()); List<Concept> members = c.getSetMembers(); Assert.assertEquals(2, members.size()); Set<String> uuids = new HashSet<String>(); for (Concept cpt : members) { uuids.add(cpt.getUuid()); } Assert.assertTrue(uuids.contains("cambodia:123")); Assert.assertTrue(uuids.contains("cambodia:456")); } |
OrderTypeLineProcessor extends BaseLineProcessor<OrderType> { @Override public OrderType fill(OrderType orderType, CsvLine line) throws IllegalArgumentException { orderType.setName(line.get(HEADER_NAME)); orderType.setDescription(line.getString(HEADER_DESC, "")); String javaClassName = line.getString(JAVA_CLASS_NAME, Order.class.getName()); if (!StringUtils.isEmpty(javaClassName)) { try { Class.forName(javaClassName); } catch (ClassNotFoundException e) { throw new IllegalArgumentException( "'" + javaClassName + "' does not represent a valid Java or OpenMRS class.", e); } orderType.setJavaClassName(javaClassName); } String parentIdentifier = line.getString(PARENT, ""); if (!StringUtils.isEmpty(parentIdentifier)) { orderType.setParent(Utils.getParentOrderType(orderService, javaClassName, parentIdentifier)); } String conceptClassesStr = line.getString(HEADER_CONCEPT_CLASSES, ""); if (!StringUtils.isEmpty(conceptClassesStr)) { orderType.setConceptClasses( new HashSet<ConceptClass>(conceptClassListParser.parseList(line.get(HEADER_CONCEPT_CLASSES)))); } return orderType; } @Autowired OrderTypeLineProcessor(@Qualifier("orderService") OrderService orderService,
ConceptClassListParser conceptClassListParser); @Override OrderType fill(OrderType orderType, CsvLine line); } | @Test public void fill_shouldParseOrderType() { String[] headerLine = { "Name", "Description", "Java class name", "Parent" }; String[] line = { "OT name", "OT desc.", "org.openmrs.Order", "01727040-a587-484d-b66a-f0afbae6c281" }; OrderTypeLineProcessor p = new OrderTypeLineProcessor(os, new ConceptClassListParser(cs)); OrderType ot = p.fill(new OrderType(), new CsvLine(headerLine, line)); Assert.assertEquals("OT name", ot.getName()); Assert.assertEquals("OT desc.", ot.getDescription()); Assert.assertEquals("org.openmrs.Order", ot.getJavaClassName()); }
@Test public void fill_shouldParseWithNameAndJavaClassNameOnly() { String[] headerLine = { "Name", "Java class name", }; String[] line = { "OT name", "org.openmrs.Order" }; OrderTypeLineProcessor p = new OrderTypeLineProcessor(os, new ConceptClassListParser(cs)); OrderType ot = p.fill(new OrderType(), new CsvLine(headerLine, line)); Assert.assertEquals("OT name", ot.getName()); Assert.assertEquals("org.openmrs.Order", ot.getJavaClassName()); } |
LocationLineProcessor extends BaseLineProcessor<Location> { @Override public Location fill(Location loc, CsvLine line) throws IllegalArgumentException { loc.setName(line.get(HEADER_NAME)); loc.setDescription(line.get(HEADER_DESC)); loc.setParentLocation(null); String parentId = line.getString(HEADER_PARENT, ""); if (!StringUtils.isEmpty(parentId)) { loc.setParentLocation(Utils.fetchLocation(parentId, locationService)); } loc.setTags(null); String tags = line.getString(HEADER_TAGS, ""); if (!StringUtils.isEmpty(tags)) { loc.setTags(new HashSet<LocationTag>(tagListParser.parseList(tags))); } setLocationTagsFromPrefixHeaders(loc, line); loc.setCityVillage(line.get(HEADER_CITY_VILLAGE)); loc.setCountyDistrict(line.get(HEADER_COUNTY_DISTRICT)); loc.setStateProvince(line.get(HEADER_STATE_PROVINCE)); loc.setPostalCode(line.get(HEADER_POSTAL_CODE)); loc.setCountry(line.get(HEADER_COUNTRY)); loc.setAddress1(line.get(HEADER_ADDRESS_1)); loc.setAddress2(line.get(HEADER_ADDRESS_2)); loc.setAddress3(line.get(HEADER_ADDRESS_3)); loc.setAddress4(line.get(HEADER_ADDRESS_4)); loc.setAddress5(line.get(HEADER_ADDRESS_5)); loc.setAddress6(line.get(HEADER_ADDRESS_6)); return loc; } @Autowired LocationLineProcessor(@Qualifier("locationService") LocationService locationService,
LocationTagListParser listParser); @Override Location fill(Location loc, CsvLine line); static final String HEADER_TAG_PREFIX; } | @Test public void fill_shouldParseTags() { String[] headerLine = { "Tags" }; String[] line = { "Login Location; Visit Location" }; LocationLineProcessor p = new LocationLineProcessor(ls, new LocationTagListParser(ls)); Location c = p.fill(new Location(), new CsvLine(headerLine, line)); Set<LocationTag> tags = c.getTags(); Assert.assertEquals(2, tags.size()); Set<String> names = new HashSet<String>(); for (LocationTag t : tags) { names.add(t.getName()); } Assert.assertTrue(names.contains("Login Location")); Assert.assertTrue(names.contains("Visit Location")); } |
OrderableCsvFile implements Comparable<OrderableCsvFile> { public File getFile() { return file; } OrderableCsvFile(File file, String checksum); Integer getOrder(); String getChecksum(); File getFile(); @Override int compareTo(OrderableCsvFile that); } | @Test public void shouldSortAccordingToCsvOrder() throws IOException { URL url = getClass().getClassLoader().getResource("org/openmrs/module/initializer/include/csv/orders"); File[] files = new File(url.getPath()).listFiles(); List<OrderableCsvFile> orderableFiles = new ArrayList<OrderableCsvFile>(); for (File f : files) { orderableFiles.add(new OrderableCsvFile(f, "")); } Collections.sort(orderableFiles); Assert.assertEquals("5_order_500.csv", orderableFiles.get(0).getFile().getName()); Assert.assertEquals("4_order_1000.csv", orderableFiles.get(1).getFile().getName()); Assert.assertEquals("1_order_1500.csv", orderableFiles.get(2).getFile().getName()); } |
BaseLineProcessor { public static String getVersion(String[] headerLine) throws IllegalArgumentException { return getMetadataValue(headerLine, VERSION_LHS); } abstract T fill(T instance, CsvLine line); static Boolean getVoidOrRetire(CsvLine line); static Map<String, Integer> createIndexMap(String[] headerLine); static int getColumn(String[] headerLine, String header); static int getColumn(Map<String, Integer> indexMap, String header); static String getMetadataValue(String[] headerLine, String fieldLhs); static String getVersion(String[] headerLine); static Integer getOrder(String[] headerLine); final static String HEADER_UUID; final static String HEADER_VOID_RETIRE; final static String HEADER_NAME; final static String HEADER_DESC; final static String HEADER_DURATION; final static String HEADER_START_TIME; final static String HEADER_END_TIME; final static String HEADER_MAX_LOAD; final static String PARENT; final static String LIST_SEPARATOR; final static String LOCALE_SEPARATOR; final static String METADATA_PREFIX; final static String VERSION_LHS; final static String ORDER_LHS; final static String UNDEFINED_METADATA_VALUE; } | @Test public void getVersion_shouldReturnTheVersionRhs() { String version = BaseLineProcessor.VERSION_LHS + "1"; Set<String> hl1 = new HashSet<String>(); hl1.add("Name"); hl1.add("Description"); hl1.add("Class"); hl1.add("Datatype"); hl1.add(version); hl1.add("Numeric unit"); hl1.add("Mapping"); Assert.assertEquals("1", BaseLineProcessor.getVersion(hl1.toArray(new String[hl1.size()]))); String[] hl2 = new String[0]; Assert.assertEquals(BaseLineProcessor.UNDEFINED_METADATA_VALUE, BaseLineProcessor.getVersion(hl2)); Set<String> hl3 = new HashSet<String>(hl1); hl3.remove(version); Assert.assertEquals(BaseLineProcessor.UNDEFINED_METADATA_VALUE, BaseLineProcessor.getVersion(hl3.toArray(new String[hl3.size()]))); }
@Test(expected = IllegalArgumentException.class) public void getVersion_shouldFailWithMultipleVersions() { String version1 = BaseLineProcessor.VERSION_LHS + "1"; String version2 = BaseLineProcessor.VERSION_LHS + "2"; Set<String> hl = new HashSet<String>(); hl.add("Name"); hl.add("Description"); hl.add(version2); hl.add("Class"); hl.add("Datatype"); hl.add(version1); hl.add("Numeric unit"); hl.add("Mapping"); BaseLineProcessor.getVersion(hl.toArray(new String[hl.size()])); }
@Test(expected = IllegalArgumentException.class) public void getVersion_shouldFailWithNull() { BaseLineProcessor.getVersion(null); } |
BaseLineProcessor { public static Map<String, Integer> createIndexMap(String[] headerLine) throws IllegalArgumentException { if (headerLine == null) { throw new IllegalArgumentException("The CSV header line cannot be null."); } Map<String, Integer> indexMap = new HashMap<String, Integer>(); int col = 0; for (String header : headerLine) { if (indexMap.containsKey(header.trim().toLowerCase())) { throw new IllegalArgumentException( "The CSV header line cannot contains twice the same header: '" + header + "'"); } indexMap.put(header.trim().toLowerCase(), col); col++; } return indexMap; } abstract T fill(T instance, CsvLine line); static Boolean getVoidOrRetire(CsvLine line); static Map<String, Integer> createIndexMap(String[] headerLine); static int getColumn(String[] headerLine, String header); static int getColumn(Map<String, Integer> indexMap, String header); static String getMetadataValue(String[] headerLine, String fieldLhs); static String getVersion(String[] headerLine); static Integer getOrder(String[] headerLine); final static String HEADER_UUID; final static String HEADER_VOID_RETIRE; final static String HEADER_NAME; final static String HEADER_DESC; final static String HEADER_DURATION; final static String HEADER_START_TIME; final static String HEADER_END_TIME; final static String HEADER_MAX_LOAD; final static String PARENT; final static String LIST_SEPARATOR; final static String LOCALE_SEPARATOR; final static String METADATA_PREFIX; final static String VERSION_LHS; final static String ORDER_LHS; final static String UNDEFINED_METADATA_VALUE; } | @Test(expected = IllegalArgumentException.class) public void createIndexMap_shouldFailWithNonUniqueHeaders() { List<String> hl1 = new ArrayList<String>(); hl1.add("Name"); hl1.add("Description"); hl1.add("Class"); hl1.add("Datatype"); hl1.add("Numeric unit"); hl1.add("Mapping"); hl1.add("Datatype"); BaseLineProcessor.createIndexMap(hl1.toArray(new String[hl1.size()])); } |
MappingsConceptLineProcessor extends ConceptLineProcessor { public Concept fill(Concept concept, CsvLine line) throws IllegalArgumentException { if (!CollectionUtils.isEmpty(concept.getConceptMappings())) { concept.getConceptMappings().clear(); } String mappingsStr = line.get(HEADER_MAPPINGS_SAMEAS); if (!StringUtils.isEmpty(mappingsStr)) { for (ConceptMap mapping : listParser.parseList(mappingsStr)) { concept.addConceptMapping(mapping); } } return concept; } @Autowired MappingsConceptLineProcessor(@Qualifier("conceptService") ConceptService conceptService,
ConceptMapListParser listParser); Concept fill(Concept concept, CsvLine line); } | @Test public void fill_shouldParseSameAsMappings() { String[] headerLine = { "Same as mappings" }; String[] line = { "cambodia:123; foo:456" }; MappingsConceptLineProcessor p = new MappingsConceptLineProcessor(cs, new ConceptMapListParser(cs)); Concept c = p.fill(new Concept(), new CsvLine(headerLine, line)); Collection<ConceptMap> mappings = c.getConceptMappings(); Assert.assertEquals(2, mappings.size()); Set<String> names = new HashSet<String>(); for (ConceptMap m : mappings) { String source = m.getConceptReferenceTerm().getConceptSource().getName(); String code = m.getConceptReferenceTerm().getCode(); names.add(source + ":" + code); } Assert.assertTrue(names.contains("cambodia:123")); Assert.assertTrue(names.contains("foo:456")); }
@Test public void fill_shouldHandleNoSameAsMappings() { String[] headerLine = { "Same as mappings" }; String[] line = { null }; MappingsConceptLineProcessor p = new MappingsConceptLineProcessor(cs, new ConceptMapListParser(cs)); Concept c = p.fill(new Concept(), new CsvLine(headerLine, line)); Assert.assertTrue(CollectionUtils.isEmpty(c.getConceptMappings())); } |
ConceptNumericLineProcessor extends ConceptLineProcessor { public Concept fill(Concept instance, CsvLine line) throws IllegalArgumentException { if (!DATATYPE_NUMERIC.equals(line.get(ConceptLineProcessor.HEADER_DATATYPE))) { return instance; } ConceptNumeric cn = new ConceptNumeric(instance); if (instance.getId() != null) { cn = conceptService.getConceptNumeric(instance.getId()); } cn.setDatatype(conceptService.getConceptDatatypeByName(DATATYPE_NUMERIC)); cn.setHiAbsolute(line.getDouble(HEADER_AH)); cn.setHiCritical(line.getDouble(HEADER_CH)); cn.setHiNormal(line.getDouble(HEADER_NH)); cn.setLowAbsolute(line.getDouble(HEADER_AL)); cn.setLowCritical(line.getDouble(HEADER_CL)); cn.setLowNormal(line.getDouble(HEADER_NL)); cn.setAllowDecimal(line.getBool(HEADER_ALLOWDECIMALS)); cn.setUnits(line.get(HEADER_UNITS)); cn.setDisplayPrecision(line.getInt(HEADER_PRECISION)); return cn; } @Autowired ConceptNumericLineProcessor(@Qualifier("conceptService") ConceptService conceptService); Concept fill(Concept instance, CsvLine line); } | @Test public void fill_shouldParseConceptNumeric() { String[] headerLine = { "Data type", "Absolute low", "Critical low", "Normal low", "Normal high", "Critical high", "Absolute high", "Units", "Allow decimals", "Display precision" }; String[] line = { "Numeric", "-100.5", "-85.7", "-50.3", "45.1", "78", "98.8", "foo", "yes", "1" }; ConceptNumericLineProcessor p = new ConceptNumericLineProcessor(cs); ConceptNumeric cn = (ConceptNumeric) p.fill(new Concept(), new CsvLine(headerLine, line)); Assert.assertEquals(ConceptNumericLineProcessor.DATATYPE_NUMERIC, cn.getDatatype().getName()); Assert.assertEquals(0, cn.getLowAbsolute().compareTo(-100.5)); Assert.assertEquals(0, cn.getLowCritical().compareTo(-85.7)); Assert.assertEquals(0, cn.getLowNormal().compareTo(-50.3)); Assert.assertEquals(0, cn.getHiNormal().compareTo(45.1)); Assert.assertEquals(0, cn.getHiCritical().compareTo(78.0)); Assert.assertEquals(0, cn.getHiAbsolute().compareTo(98.8)); Assert.assertEquals("foo", cn.getUnits()); Assert.assertTrue(cn.getAllowDecimal()); Assert.assertEquals(1, cn.getDisplayPrecision().intValue()); }
@Test public void fill_shouldHandleMissingHeaders() { String[] headerLine = {}; String[] line = {}; ConceptNumericLineProcessor p = new ConceptNumericLineProcessor(cs); Concept c = p.fill(new Concept(), new CsvLine(headerLine, line)); Assert.assertFalse(c instanceof ConceptNumeric); }
@Test(expected = NumberFormatException.class) public void fill_shouldFailWhenCannotParse() { String[] headerLine = { "Data type", "Absolute low" }; String[] line = { "Numeric", "-100.5a" }; ConceptNumericLineProcessor p = new ConceptNumericLineProcessor(cs); p.fill(new Concept(), new CsvLine(headerLine, line)); } |
MealyFilter { @SafeVarargs public static <I, O> CompactMealy<I, O> pruneTransitionsWithOutput(MealyMachine<?, I, ?, O> in, Alphabet<I> inputs, O... outputs) { return pruneTransitionsWithOutput(in, inputs, Arrays.asList(outputs)); } private MealyFilter(); @SafeVarargs static CompactMealy<I, O> pruneTransitionsWithOutput(MealyMachine<?, I, ?, O> in,
Alphabet<I> inputs,
O... outputs); static CompactMealy<I, O> pruneTransitionsWithOutput(MealyMachine<?, I, ?, O> in,
Alphabet<I> inputs,
Collection<? super O> outputs); static CompactMealy<I, O> filterByOutput(MealyMachine<?, I, ?, O> in,
Alphabet<I> inputs,
Predicate<? super O> outputPred); static Mapping<S1, S2> filterByOutput(MealyMachine<S1, I, T1, O> in,
Collection<? extends I> inputs,
MutableMealyMachine<S2, I, ?, O> out,
Predicate<? super O> outputPred); @SafeVarargs static CompactMealy<I, O> retainTransitionsWithOutput(MealyMachine<?, I, ?, O> in,
Alphabet<I> inputs,
O... outputs); static CompactMealy<I, O> retainTransitionsWithOutput(MealyMachine<?, I, ?, O> in,
Alphabet<I> inputs,
Collection<? super O> outputs); } | @Test public void testPruneTransitionWithOutput() { Word<Integer> testWord = Word.fromSymbols(1, 1, 1); WordBuilder<String> testOutput = new WordBuilder<>(3); Assert.assertTrue(testMealy.trace(testWord, testOutput)); Assert.assertEquals(testOutput.toWord(), Word.fromSymbols("a", "b", "c")); testOutput.clear(); MealyMachine<?, Integer, ?, String> mealy1 = MealyFilter.pruneTransitionsWithOutput(testMealy, testAlphabet, "c"); Assert.assertEquals(mealy1.size(), 3); Assert.assertFalse(mealy1.trace(testWord, testOutput)); Assert.assertEquals(testOutput.toWord(), Word.fromSymbols("a", "b")); testOutput.clear(); MealyMachine<?, Integer, ?, String> mealy2 = MealyFilter.pruneTransitionsWithOutput(testMealy, testAlphabet, "b", "c"); Assert.assertEquals(mealy2.size(), 2); Assert.assertFalse(mealy2.trace(testWord, testOutput)); Assert.assertEquals(testOutput.toWord(), Word.fromSymbols("a")); testOutput.clear(); MealyMachine<?, Integer, ?, String> mealy3 = MealyFilter.pruneTransitionsWithOutput(testMealy, testAlphabet, "a"); Assert.assertEquals(mealy3.size(), 1); Assert.assertFalse(mealy3.trace(testWord, testOutput)); Assert.assertEquals(testOutput.toWord(), Word.epsilon()); } |
DFAs { public static <I> CompactDFA<I> xor(DFA<?, I> dfa1, DFA<?, I> dfa2, Alphabet<I> inputAlphabet) { return xor(dfa1, dfa2, inputAlphabet, new CompactDFA<>(inputAlphabet)); } private DFAs(); static CompactDFA<I> combine(DFA<?, I> dfa1,
DFA<?, I> dfa2,
Alphabet<I> inputAlphabet,
AcceptanceCombiner combiner); static A combine(DFA<?, I> dfa1,
DFA<?, I> dfa2,
Collection<? extends I> inputs,
A out,
AcceptanceCombiner combiner); static CompactDFA<I> and(DFA<?, I> dfa1, DFA<?, I> dfa2, Alphabet<I> inputAlphabet); static A and(DFA<?, I> dfa1,
DFA<?, I> dfa2,
Collection<? extends I> inputs,
A out); static CompactDFA<I> or(DFA<?, I> dfa1, DFA<?, I> dfa2, Alphabet<I> inputAlphabet); static A or(DFA<?, I> dfa1,
DFA<?, I> dfa2,
Collection<? extends I> inputs,
A out); static CompactDFA<I> xor(DFA<?, I> dfa1, DFA<?, I> dfa2, Alphabet<I> inputAlphabet); static A xor(DFA<?, I> dfa1,
DFA<?, I> dfa2,
Collection<? extends I> inputs,
A out); static CompactDFA<I> equiv(DFA<?, I> dfa1, DFA<?, I> dfa2, Alphabet<I> inputAlphabet); static A equiv(DFA<?, I> dfa1,
DFA<?, I> dfa2,
Collection<? extends I> inputs,
A out); static CompactDFA<I> impl(DFA<?, I> dfa1, DFA<?, I> dfa2, Alphabet<I> inputAlphabet); static A impl(DFA<?, I> dfa1,
DFA<?, I> dfa2,
Collection<? extends I> inputs,
A out); static CompactDFA<I> complement(DFA<?, I> dfa, Alphabet<I> inputAlphabet); static A complement(DFA<?, I> dfa,
Collection<? extends I> inputs,
A out); static CompactDFA<I> complete(DFA<?, I> dfa, Alphabet<I> inputs); static A complete(DFA<?, I> dfa, Collection<? extends I> inputs, A out); static CompactDFA<I> minimize(DFA<?, I> dfa, Alphabet<I> alphabet); static CompactDFA<I> minimize(A dfa); static boolean isPrefixClosed(DFA<S, I> dfa, Alphabet<I> alphabet); static boolean acceptsEmptyLanguage(DFA<S, ?> dfa); } | @Test public void testXor() { DFA<?, Integer> expected = forVector(XOR_RESULT); DFA<?, Integer> actual = DFAs.xor(testDfa1, testDfa2, testAlphabet); Assert.assertTrue(Automata.testEquivalence(actual, expected, testAlphabet)); } |
DFAs { public static <I> CompactDFA<I> equiv(DFA<?, I> dfa1, DFA<?, I> dfa2, Alphabet<I> inputAlphabet) { return equiv(dfa1, dfa2, inputAlphabet, new CompactDFA<>(inputAlphabet)); } private DFAs(); static CompactDFA<I> combine(DFA<?, I> dfa1,
DFA<?, I> dfa2,
Alphabet<I> inputAlphabet,
AcceptanceCombiner combiner); static A combine(DFA<?, I> dfa1,
DFA<?, I> dfa2,
Collection<? extends I> inputs,
A out,
AcceptanceCombiner combiner); static CompactDFA<I> and(DFA<?, I> dfa1, DFA<?, I> dfa2, Alphabet<I> inputAlphabet); static A and(DFA<?, I> dfa1,
DFA<?, I> dfa2,
Collection<? extends I> inputs,
A out); static CompactDFA<I> or(DFA<?, I> dfa1, DFA<?, I> dfa2, Alphabet<I> inputAlphabet); static A or(DFA<?, I> dfa1,
DFA<?, I> dfa2,
Collection<? extends I> inputs,
A out); static CompactDFA<I> xor(DFA<?, I> dfa1, DFA<?, I> dfa2, Alphabet<I> inputAlphabet); static A xor(DFA<?, I> dfa1,
DFA<?, I> dfa2,
Collection<? extends I> inputs,
A out); static CompactDFA<I> equiv(DFA<?, I> dfa1, DFA<?, I> dfa2, Alphabet<I> inputAlphabet); static A equiv(DFA<?, I> dfa1,
DFA<?, I> dfa2,
Collection<? extends I> inputs,
A out); static CompactDFA<I> impl(DFA<?, I> dfa1, DFA<?, I> dfa2, Alphabet<I> inputAlphabet); static A impl(DFA<?, I> dfa1,
DFA<?, I> dfa2,
Collection<? extends I> inputs,
A out); static CompactDFA<I> complement(DFA<?, I> dfa, Alphabet<I> inputAlphabet); static A complement(DFA<?, I> dfa,
Collection<? extends I> inputs,
A out); static CompactDFA<I> complete(DFA<?, I> dfa, Alphabet<I> inputs); static A complete(DFA<?, I> dfa, Collection<? extends I> inputs, A out); static CompactDFA<I> minimize(DFA<?, I> dfa, Alphabet<I> alphabet); static CompactDFA<I> minimize(A dfa); static boolean isPrefixClosed(DFA<S, I> dfa, Alphabet<I> alphabet); static boolean acceptsEmptyLanguage(DFA<S, ?> dfa); } | @Test public void testEquiv() { DFA<?, Integer> expected = forVector(EQUIV_RESULT); DFA<?, Integer> actual = DFAs.equiv(testDfa1, testDfa2, testAlphabet); Assert.assertTrue(Automata.testEquivalence(actual, expected, testAlphabet)); } |
DFAs { public static <I> CompactDFA<I> impl(DFA<?, I> dfa1, DFA<?, I> dfa2, Alphabet<I> inputAlphabet) { return impl(dfa1, dfa2, inputAlphabet, new CompactDFA<>(inputAlphabet)); } private DFAs(); static CompactDFA<I> combine(DFA<?, I> dfa1,
DFA<?, I> dfa2,
Alphabet<I> inputAlphabet,
AcceptanceCombiner combiner); static A combine(DFA<?, I> dfa1,
DFA<?, I> dfa2,
Collection<? extends I> inputs,
A out,
AcceptanceCombiner combiner); static CompactDFA<I> and(DFA<?, I> dfa1, DFA<?, I> dfa2, Alphabet<I> inputAlphabet); static A and(DFA<?, I> dfa1,
DFA<?, I> dfa2,
Collection<? extends I> inputs,
A out); static CompactDFA<I> or(DFA<?, I> dfa1, DFA<?, I> dfa2, Alphabet<I> inputAlphabet); static A or(DFA<?, I> dfa1,
DFA<?, I> dfa2,
Collection<? extends I> inputs,
A out); static CompactDFA<I> xor(DFA<?, I> dfa1, DFA<?, I> dfa2, Alphabet<I> inputAlphabet); static A xor(DFA<?, I> dfa1,
DFA<?, I> dfa2,
Collection<? extends I> inputs,
A out); static CompactDFA<I> equiv(DFA<?, I> dfa1, DFA<?, I> dfa2, Alphabet<I> inputAlphabet); static A equiv(DFA<?, I> dfa1,
DFA<?, I> dfa2,
Collection<? extends I> inputs,
A out); static CompactDFA<I> impl(DFA<?, I> dfa1, DFA<?, I> dfa2, Alphabet<I> inputAlphabet); static A impl(DFA<?, I> dfa1,
DFA<?, I> dfa2,
Collection<? extends I> inputs,
A out); static CompactDFA<I> complement(DFA<?, I> dfa, Alphabet<I> inputAlphabet); static A complement(DFA<?, I> dfa,
Collection<? extends I> inputs,
A out); static CompactDFA<I> complete(DFA<?, I> dfa, Alphabet<I> inputs); static A complete(DFA<?, I> dfa, Collection<? extends I> inputs, A out); static CompactDFA<I> minimize(DFA<?, I> dfa, Alphabet<I> alphabet); static CompactDFA<I> minimize(A dfa); static boolean isPrefixClosed(DFA<S, I> dfa, Alphabet<I> alphabet); static boolean acceptsEmptyLanguage(DFA<S, ?> dfa); } | @Test public void testImpl() { DFA<?, Integer> expected = forVector(IMPL_RESULT); DFA<?, Integer> actual = DFAs.impl(testDfa1, testDfa2, testAlphabet); Assert.assertTrue(Automata.testEquivalence(actual, expected, testAlphabet)); } |
DFAs { public static <I> CompactDFA<I> complement(DFA<?, I> dfa, Alphabet<I> inputAlphabet) { return complement(dfa, inputAlphabet, new CompactDFA<>(inputAlphabet)); } private DFAs(); static CompactDFA<I> combine(DFA<?, I> dfa1,
DFA<?, I> dfa2,
Alphabet<I> inputAlphabet,
AcceptanceCombiner combiner); static A combine(DFA<?, I> dfa1,
DFA<?, I> dfa2,
Collection<? extends I> inputs,
A out,
AcceptanceCombiner combiner); static CompactDFA<I> and(DFA<?, I> dfa1, DFA<?, I> dfa2, Alphabet<I> inputAlphabet); static A and(DFA<?, I> dfa1,
DFA<?, I> dfa2,
Collection<? extends I> inputs,
A out); static CompactDFA<I> or(DFA<?, I> dfa1, DFA<?, I> dfa2, Alphabet<I> inputAlphabet); static A or(DFA<?, I> dfa1,
DFA<?, I> dfa2,
Collection<? extends I> inputs,
A out); static CompactDFA<I> xor(DFA<?, I> dfa1, DFA<?, I> dfa2, Alphabet<I> inputAlphabet); static A xor(DFA<?, I> dfa1,
DFA<?, I> dfa2,
Collection<? extends I> inputs,
A out); static CompactDFA<I> equiv(DFA<?, I> dfa1, DFA<?, I> dfa2, Alphabet<I> inputAlphabet); static A equiv(DFA<?, I> dfa1,
DFA<?, I> dfa2,
Collection<? extends I> inputs,
A out); static CompactDFA<I> impl(DFA<?, I> dfa1, DFA<?, I> dfa2, Alphabet<I> inputAlphabet); static A impl(DFA<?, I> dfa1,
DFA<?, I> dfa2,
Collection<? extends I> inputs,
A out); static CompactDFA<I> complement(DFA<?, I> dfa, Alphabet<I> inputAlphabet); static A complement(DFA<?, I> dfa,
Collection<? extends I> inputs,
A out); static CompactDFA<I> complete(DFA<?, I> dfa, Alphabet<I> inputs); static A complete(DFA<?, I> dfa, Collection<? extends I> inputs, A out); static CompactDFA<I> minimize(DFA<?, I> dfa, Alphabet<I> alphabet); static CompactDFA<I> minimize(A dfa); static boolean isPrefixClosed(DFA<S, I> dfa, Alphabet<I> alphabet); static boolean acceptsEmptyLanguage(DFA<S, ?> dfa); } | @Test public void testComplement() { DFA<?, Integer> expected = forVector(VECTOR_1_NEG); DFA<?, Integer> actual = DFAs.complement(testDfa1, testAlphabet); Assert.assertTrue(Automata.testEquivalence(actual, expected, testAlphabet)); } |
DFAs { public static <S, I> boolean isPrefixClosed(DFA<S, I> dfa, Alphabet<I> alphabet) { return dfa.getStates() .parallelStream() .allMatch(s -> dfa.isAccepting(s) || alphabet.parallelStream().noneMatch(i -> dfa.isAccepting(dfa.getSuccessors(s, i)))); } private DFAs(); static CompactDFA<I> combine(DFA<?, I> dfa1,
DFA<?, I> dfa2,
Alphabet<I> inputAlphabet,
AcceptanceCombiner combiner); static A combine(DFA<?, I> dfa1,
DFA<?, I> dfa2,
Collection<? extends I> inputs,
A out,
AcceptanceCombiner combiner); static CompactDFA<I> and(DFA<?, I> dfa1, DFA<?, I> dfa2, Alphabet<I> inputAlphabet); static A and(DFA<?, I> dfa1,
DFA<?, I> dfa2,
Collection<? extends I> inputs,
A out); static CompactDFA<I> or(DFA<?, I> dfa1, DFA<?, I> dfa2, Alphabet<I> inputAlphabet); static A or(DFA<?, I> dfa1,
DFA<?, I> dfa2,
Collection<? extends I> inputs,
A out); static CompactDFA<I> xor(DFA<?, I> dfa1, DFA<?, I> dfa2, Alphabet<I> inputAlphabet); static A xor(DFA<?, I> dfa1,
DFA<?, I> dfa2,
Collection<? extends I> inputs,
A out); static CompactDFA<I> equiv(DFA<?, I> dfa1, DFA<?, I> dfa2, Alphabet<I> inputAlphabet); static A equiv(DFA<?, I> dfa1,
DFA<?, I> dfa2,
Collection<? extends I> inputs,
A out); static CompactDFA<I> impl(DFA<?, I> dfa1, DFA<?, I> dfa2, Alphabet<I> inputAlphabet); static A impl(DFA<?, I> dfa1,
DFA<?, I> dfa2,
Collection<? extends I> inputs,
A out); static CompactDFA<I> complement(DFA<?, I> dfa, Alphabet<I> inputAlphabet); static A complement(DFA<?, I> dfa,
Collection<? extends I> inputs,
A out); static CompactDFA<I> complete(DFA<?, I> dfa, Alphabet<I> inputs); static A complete(DFA<?, I> dfa, Collection<? extends I> inputs, A out); static CompactDFA<I> minimize(DFA<?, I> dfa, Alphabet<I> alphabet); static CompactDFA<I> minimize(A dfa); static boolean isPrefixClosed(DFA<S, I> dfa, Alphabet<I> alphabet); static boolean acceptsEmptyLanguage(DFA<S, ?> dfa); } | @Test public void testIsPrefixClosed() { Assert.assertFalse(DFAs.isPrefixClosed(forVector(VECTOR_1), testAlphabet)); Assert.assertFalse(DFAs.isPrefixClosed(forVector(VECTOR_1_NEG), testAlphabet)); Assert.assertFalse(DFAs.isPrefixClosed(forVector(VECTOR_2), testAlphabet)); Assert.assertTrue(DFAs.isPrefixClosed(forVector(true, true, true, true), testAlphabet)); Assert.assertTrue(DFAs.isPrefixClosed(forVector(false, false, false, false), testAlphabet)); } |
DFAs { public static <S> boolean acceptsEmptyLanguage(DFA<S, ?> dfa) { return dfa.getStates().stream().noneMatch(dfa::isAccepting); } private DFAs(); static CompactDFA<I> combine(DFA<?, I> dfa1,
DFA<?, I> dfa2,
Alphabet<I> inputAlphabet,
AcceptanceCombiner combiner); static A combine(DFA<?, I> dfa1,
DFA<?, I> dfa2,
Collection<? extends I> inputs,
A out,
AcceptanceCombiner combiner); static CompactDFA<I> and(DFA<?, I> dfa1, DFA<?, I> dfa2, Alphabet<I> inputAlphabet); static A and(DFA<?, I> dfa1,
DFA<?, I> dfa2,
Collection<? extends I> inputs,
A out); static CompactDFA<I> or(DFA<?, I> dfa1, DFA<?, I> dfa2, Alphabet<I> inputAlphabet); static A or(DFA<?, I> dfa1,
DFA<?, I> dfa2,
Collection<? extends I> inputs,
A out); static CompactDFA<I> xor(DFA<?, I> dfa1, DFA<?, I> dfa2, Alphabet<I> inputAlphabet); static A xor(DFA<?, I> dfa1,
DFA<?, I> dfa2,
Collection<? extends I> inputs,
A out); static CompactDFA<I> equiv(DFA<?, I> dfa1, DFA<?, I> dfa2, Alphabet<I> inputAlphabet); static A equiv(DFA<?, I> dfa1,
DFA<?, I> dfa2,
Collection<? extends I> inputs,
A out); static CompactDFA<I> impl(DFA<?, I> dfa1, DFA<?, I> dfa2, Alphabet<I> inputAlphabet); static A impl(DFA<?, I> dfa1,
DFA<?, I> dfa2,
Collection<? extends I> inputs,
A out); static CompactDFA<I> complement(DFA<?, I> dfa, Alphabet<I> inputAlphabet); static A complement(DFA<?, I> dfa,
Collection<? extends I> inputs,
A out); static CompactDFA<I> complete(DFA<?, I> dfa, Alphabet<I> inputs); static A complete(DFA<?, I> dfa, Collection<? extends I> inputs, A out); static CompactDFA<I> minimize(DFA<?, I> dfa, Alphabet<I> alphabet); static CompactDFA<I> minimize(A dfa); static boolean isPrefixClosed(DFA<S, I> dfa, Alphabet<I> alphabet); static boolean acceptsEmptyLanguage(DFA<S, ?> dfa); } | @Test public void testAcceptsEmptyLanguage() { Assert.assertTrue(DFAs.acceptsEmptyLanguage(forVector(false))); Assert.assertFalse(DFAs.acceptsEmptyLanguage(forVector(true))); } |
Graphs { public static <N, E> Mapping<N, @Nullable Collection<E>> incomingEdges(final Graph<N, E> graph) { if (graph instanceof BidirectionalGraph) { final BidirectionalGraph<N, E> bdGraph = (BidirectionalGraph<N, E>) graph; return bdGraph::getIncomingEdges; } MutableMapping<N, @Nullable Collection<E>> inEdgesMapping = graph.createStaticNodeMapping(); for (N node : graph) { Collection<E> outEdges = graph.getOutgoingEdges(node); for (E e : outEdges) { N tgt = graph.getTarget(e); Collection<E> inEdges = inEdgesMapping.get(tgt); if (inEdges == null) { inEdges = new ArrayList<>(); inEdgesMapping.put(tgt, inEdges); } inEdges.add(e); } } return inEdgesMapping; } private Graphs(); static Mapping<N, @Nullable Collection<E>> incomingEdges(final Graph<N, E> graph); static Path<N, E> findShortestPath(final IndefiniteGraph<N, E> graph,
int limit,
N start,
Collection<? extends N> targets); static Path<N, E> findShortestPath(IndefiniteGraph<N, E> graph,
int limit,
N start,
Predicate<? super N> targetPred); static List<N> toNodeList(List<E> edgeList, Graph<N, E> graph, N init); static APSPResult<N, E> findAPSP(Graph<N, E> graph, EdgeWeights<E> edgeWeights); static SSSPResult<N, E> findSSSP(Graph<N, E> graph, N init, EdgeWeights<E> edgeWeights); static List<List<N>> collectSCCs(Graph<N, E> graph); static void findSCCs(Graph<N, E> graph, SCCListener<N> sccListener); static final float INVALID_DISTANCE; } | @Test public void testIncomingEdges() { final Alphabet<Integer> alphabet = Alphabets.integers(1, 3); final DFA<?, Integer> dfa = RandomAutomata.randomDFA(new Random(42), 10, alphabet); checkIncomingEdges(dfa, alphabet, new CompactGraph<>(dfa.size())); checkIncomingEdges(dfa, alphabet, new CompactSimpleGraph<>(dfa.size())); checkIncomingEdges(dfa, alphabet, new CompactSimpleBidiGraph<>(dfa.size())); checkIncomingEdges(dfa, alphabet, new SimpleMapGraph<>()); } |
IntRange extends AbstractList<Integer> implements ArrayWritable<Integer>, RandomAccess, Serializable { @Override public int size() { return size; } IntRange(int start, int end); IntRange(int start, int end, int step); @Override Integer get(int index); int intGet(int index); int intValue(int i); @Override boolean contains(@Nullable Object o); @Override int indexOf(@Nullable Object o); int indexOf(int i); @Override int lastIndexOf(@Nullable Object o); @Override IntRangeIterator iterator(); @Override IntRangeIterator listIterator(); @Override IntRangeIterator listIterator(int index); @Override int size(); @Override void writeToArray(int offset, @Nullable Object[] array, int tgtOfs, int num); } | @Test public void testSize() { Assert.assertEquals(ir0.size(), 10); Assert.assertEquals(ir1.size(), 4); } |
IntRange extends AbstractList<Integer> implements ArrayWritable<Integer>, RandomAccess, Serializable { @Override public Integer get(int index) { return Integer.valueOf(intGet(index)); } IntRange(int start, int end); IntRange(int start, int end, int step); @Override Integer get(int index); int intGet(int index); int intValue(int i); @Override boolean contains(@Nullable Object o); @Override int indexOf(@Nullable Object o); int indexOf(int i); @Override int lastIndexOf(@Nullable Object o); @Override IntRangeIterator iterator(); @Override IntRangeIterator listIterator(); @Override IntRangeIterator listIterator(int index); @Override int size(); @Override void writeToArray(int offset, @Nullable Object[] array, int tgtOfs, int num); } | @Test public void testGet() { Assert.assertEquals(ir0.get(0).intValue(), 10); Assert.assertEquals(ir0.get(4).intValue(), 14); Assert.assertEquals(ir1.get(2).intValue(), 26); Assert.assertEquals(ir1.get(3).intValue(), 29); } |
IntRange extends AbstractList<Integer> implements ArrayWritable<Integer>, RandomAccess, Serializable { @Override public IntRangeIterator iterator() { return new IntRangeIterator(start, step, size); } IntRange(int start, int end); IntRange(int start, int end, int step); @Override Integer get(int index); int intGet(int index); int intValue(int i); @Override boolean contains(@Nullable Object o); @Override int indexOf(@Nullable Object o); int indexOf(int i); @Override int lastIndexOf(@Nullable Object o); @Override IntRangeIterator iterator(); @Override IntRangeIterator listIterator(); @Override IntRangeIterator listIterator(int index); @Override int size(); @Override void writeToArray(int offset, @Nullable Object[] array, int tgtOfs, int num); } | @Test public void testIterator() { testIterator(ir0); testIterator(ir1); } |
MealyMachines { public static <I, O1, O2> CompactMealy<I, Pair<O1, O2>> combine(MealyMachine<?, I, ?, O1> mealy1, MealyMachine<?, I, ?, O2> mealy2, Alphabet<I> inputAlphabet) { return combine(mealy1, mealy2, inputAlphabet, new CompactMealy<>(inputAlphabet)); } private MealyMachines(); static CompactMealy<I, Pair<O1, O2>> combine(MealyMachine<?, I, ?, O1> mealy1,
MealyMachine<?, I, ?, O2> mealy2,
Alphabet<I> inputAlphabet); static A combine(MealyMachine<?, I, ?, O1> mealy1,
MealyMachine<?, I, ?, O2> mealy2,
Collection<? extends I> inputs,
A out); static CompactMealy<I, O> complete(MealyMachine<?, I, ?, O> mealy,
Alphabet<I> inputs,
O undefinedOutput); static A complete(MealyMachine<?, I, ?, O> mealy,
Collection<? extends I> inputs,
O undefinedOutput,
A out); } | @Test public void testProductAutomaton() { final CompactMealy<Character, Pair<Integer, Integer>> product = MealyMachines.combine(mealy1, mealy2, alphabet); final Word<Character> completeInput = Word.fromCharSequence("abcabcabc"); final Word<Character> partialInput = Word.fromCharSequence("abcbbb"); final Word<Character> undefinedInput = Word.fromCharSequence("abbbbb"); final Word<Pair<Integer, Integer>> completeOutput = product.computeOutput(completeInput); final Word<Pair<Integer, Integer>> partialOutput = product.computeOutput(partialInput); final Word<Pair<Integer, Integer>> undefinedOutput = product.computeOutput(undefinedInput); Assert.assertEquals(completeOutput.size(), completeInput.size()); Assert.assertTrue(completeOutput.stream().allMatch(out -> out.getFirst() + out.getSecond() == 4)); Assert.assertEquals(partialOutput.size(), partialInput.size()); Assert.assertTrue(partialOutput.stream().map(Pair::getSecond).allMatch(Objects::nonNull)); Assert.assertTrue(partialOutput.stream().map(Pair::getFirst).anyMatch(Objects::isNull)); Assert.assertEquals(undefinedOutput.size(), 2); } |
ReusableIterator implements Iterable<T> { @Override public Iterator<T> iterator() { return new CopyOnReadIterator(this.iterator); } ReusableIterator(Iterator<T> iterator); ReusableIterator(Iterator<T> iterator, List<T> cache); @Override Iterator<T> iterator(); } | @Test public void testIterator() { final int size = 10; final Iterator<Integer> iterator = IntStream.range(0, size).iterator(); final Iterable<Integer> iterable = new ReusableIterator<>(iterator); final Iterator<Integer> iter1 = iterable.iterator(); final int firstLimit = 3; for (int i = 0; i < firstLimit; i++) { Assert.assertEquals(iter1.next(), Integer.valueOf(i)); } final Iterator<Integer> iter2 = iterable.iterator(); final int secondLimit = 8; for (int i = 0; i < secondLimit; i++) { Assert.assertEquals(iter2.next(), Integer.valueOf(i)); } final Iterator<Integer> iter3 = iterable.iterator(); final int thirdLimit = 5; for (int i = 0; i < thirdLimit; i++) { Assert.assertEquals(iter3.next(), Integer.valueOf(i)); } for (int i = firstLimit; i < size; i++) { Assert.assertEquals(iter1.next(), Integer.valueOf(i)); } Assert.assertFalse(iter1.hasNext()); for (int i = secondLimit; i < size; i++) { Assert.assertEquals(iter2.next(), Integer.valueOf(i)); } Assert.assertFalse(iter2.hasNext()); for (int i = thirdLimit; i < size; i++) { Assert.assertEquals(iter3.next(), Integer.valueOf(i)); } Assert.assertFalse(iter3.hasNext()); } |
CharRange extends AbstractList<Character> implements ArrayWritable<Character>, RandomAccess, Serializable { @Override public CharRangeIterator listIterator() { return new CharRangeIterator(delegate.listIterator()); } CharRange(char low, char high); CharRange(char low, char high, int step); CharRange(IntRange delegate); @Override Character get(int index); char charGet(int index); @Override boolean contains(@Nullable Object o); @Override int indexOf(@Nullable Object o); int indexOf(char c); @Override int lastIndexOf(@Nullable Object o); @Override CharRangeIterator iterator(); @Override CharRangeIterator listIterator(); @Override CharRangeIterator listIterator(int index); @Override int size(); @Override void writeToArray(int offset, @Nullable Object[] array, int tgtOfs, int num); char charValue(int i); } | @Test public void testListIterator() { ListIterator<Character> iterator = range.listIterator(range.size() + 1); Assert.assertEquals(iterator.nextIndex(), range.size()); Assert.assertThrows(NoSuchElementException.class, iterator::next); for (char i = end; i >= start; i--) { Assert.assertTrue(iterator.hasPrevious()); Assert.assertEquals(iterator.previous(), Character.valueOf(i)); } Assert.assertFalse(iterator.hasPrevious()); Assert.assertTrue(iterator.hasNext()); Assert.assertEquals(iterator.nextIndex(), 0); Assert.assertEquals(iterator.previousIndex(), -1); Assert.assertThrows(NoSuchElementException.class, iterator::previous); } |
StringUtil { public static String enquote(String s) { StringBuilder sb = new StringBuilder(s.length() + 2); try { enquote(s, sb); } catch (IOException e) { LOGGER.error("Could not enquote String", e); } return sb.toString(); } private StringUtil(); static String enquote(String s); static void enquote(String s, Appendable a); static Pattern getIdentifierPattern(); static String enquoteIfNecessary(String s); static void enquoteIfNecessary(String s, Appendable a); static String enquoteIfNecessary(String s, Pattern p); static void enquoteIfNecessary(String s, Appendable a, Pattern valid); static void enquoteIfNecessary(String s, Appendable a, Pattern valid, Pattern exception); static String unquote(String s); static void unquote(String s, Appendable a); static String unescapeQuotes(String s); static void unescapeQuotes(String s, Appendable a); static String escapeQuotes(String s); static void escapeQuotes(String s, Appendable a); static void appendArray(Appendable a, Object[] array, String sepString); static void appendArrayEnquoted(Appendable a, Object[] array, String sepString); static void appendIterable(Appendable a, Iterable<?> it, String sepString); static void appendIterableEnquoted(Appendable a, Iterable<?> it, String sepString); static void appendObject(Appendable a, @Nullable Object obj); } | @Test public void testEnquote() { Assert.assertEquals(StringUtil.enquote(""), "\"\""); Assert.assertEquals(StringUtil.enquote("abc"), "\"abc\""); Assert.assertEquals(StringUtil.enquote("\"abc\""), "\"\\\"abc\\\"\""); Assert.assertEquals(StringUtil.enquote("ab\"c"), "\"ab\\\"c\""); Assert.assertEquals(StringUtil.enquote("ab\\\"c"), "\"ab\\\\\\\"c\""); } |
StringUtil { public static String enquoteIfNecessary(String s) { StringBuilder sb = new StringBuilder(); try { enquoteIfNecessary(s, sb); return sb.toString(); } catch (IOException ex) { throw new AssertionError("StringBuilder should not throw", ex); } } private StringUtil(); static String enquote(String s); static void enquote(String s, Appendable a); static Pattern getIdentifierPattern(); static String enquoteIfNecessary(String s); static void enquoteIfNecessary(String s, Appendable a); static String enquoteIfNecessary(String s, Pattern p); static void enquoteIfNecessary(String s, Appendable a, Pattern valid); static void enquoteIfNecessary(String s, Appendable a, Pattern valid, Pattern exception); static String unquote(String s); static void unquote(String s, Appendable a); static String unescapeQuotes(String s); static void unescapeQuotes(String s, Appendable a); static String escapeQuotes(String s); static void escapeQuotes(String s, Appendable a); static void appendArray(Appendable a, Object[] array, String sepString); static void appendArrayEnquoted(Appendable a, Object[] array, String sepString); static void appendIterable(Appendable a, Iterable<?> it, String sepString); static void appendIterableEnquoted(Appendable a, Iterable<?> it, String sepString); static void appendObject(Appendable a, @Nullable Object obj); } | @Test public void testEnquoteIfNecessary() { Assert.assertEquals(StringUtil.enquoteIfNecessary(""), ""); Assert.assertEquals(StringUtil.enquoteIfNecessary("abc"), "abc"); Assert.assertEquals(StringUtil.enquoteIfNecessary("\"abc\""), "\"\\\"abc\\\"\""); Assert.assertEquals(StringUtil.enquoteIfNecessary("ab\"c"), "\"ab\\\"c\""); Assert.assertEquals(StringUtil.enquoteIfNecessary("ab\\\"c"), "\"ab\\\\\\\"c\""); } |
StringUtil { public static String unquote(String s) { if (s.length() < 2) { throw new IllegalArgumentException( "Argument to StringUtil.unquote() must begin and end with a double quote ('\"')."); } StringBuilder sb = new StringBuilder(s.length() - 2); try { unquote(s, sb); } catch (IOException e) { LOGGER.error("Could not unquote String", e); } return sb.toString(); } private StringUtil(); static String enquote(String s); static void enquote(String s, Appendable a); static Pattern getIdentifierPattern(); static String enquoteIfNecessary(String s); static void enquoteIfNecessary(String s, Appendable a); static String enquoteIfNecessary(String s, Pattern p); static void enquoteIfNecessary(String s, Appendable a, Pattern valid); static void enquoteIfNecessary(String s, Appendable a, Pattern valid, Pattern exception); static String unquote(String s); static void unquote(String s, Appendable a); static String unescapeQuotes(String s); static void unescapeQuotes(String s, Appendable a); static String escapeQuotes(String s); static void escapeQuotes(String s, Appendable a); static void appendArray(Appendable a, Object[] array, String sepString); static void appendArrayEnquoted(Appendable a, Object[] array, String sepString); static void appendIterable(Appendable a, Iterable<?> it, String sepString); static void appendIterableEnquoted(Appendable a, Iterable<?> it, String sepString); static void appendObject(Appendable a, @Nullable Object obj); } | @Test public void testUnquote() { Assert.expectThrows(IllegalArgumentException.class, () -> StringUtil.unquote("")); Assert.expectThrows(IllegalArgumentException.class, () -> StringUtil.unquote("abc")); Assert.assertEquals(StringUtil.unquote("\"abc\""), "abc"); Assert.assertEquals(StringUtil.unquote("\"ab\"c\""), "ab\"c"); Assert.assertEquals(StringUtil.unquote("\"ab\\\"c\""), "ab\"c"); Assert.assertEquals(StringUtil.unquote("\"ab\\\\\"c\""), "ab\\\"c"); } |
StringUtil { public static String escapeQuotes(String s) { StringBuilder sb = new StringBuilder(s.length()); try { escapeQuotes(s, sb); } catch (IOException e) { LOGGER.error("Could not escape quotes", e); } return sb.toString(); } private StringUtil(); static String enquote(String s); static void enquote(String s, Appendable a); static Pattern getIdentifierPattern(); static String enquoteIfNecessary(String s); static void enquoteIfNecessary(String s, Appendable a); static String enquoteIfNecessary(String s, Pattern p); static void enquoteIfNecessary(String s, Appendable a, Pattern valid); static void enquoteIfNecessary(String s, Appendable a, Pattern valid, Pattern exception); static String unquote(String s); static void unquote(String s, Appendable a); static String unescapeQuotes(String s); static void unescapeQuotes(String s, Appendable a); static String escapeQuotes(String s); static void escapeQuotes(String s, Appendable a); static void appendArray(Appendable a, Object[] array, String sepString); static void appendArrayEnquoted(Appendable a, Object[] array, String sepString); static void appendIterable(Appendable a, Iterable<?> it, String sepString); static void appendIterableEnquoted(Appendable a, Iterable<?> it, String sepString); static void appendObject(Appendable a, @Nullable Object obj); } | @Test public void testEscapeQuotes() { Assert.assertEquals(StringUtil.escapeQuotes(""), ""); Assert.assertEquals(StringUtil.escapeQuotes("abc"), "abc"); Assert.assertEquals(StringUtil.escapeQuotes("\"abc\""), "\\\"abc\\\""); Assert.assertEquals(StringUtil.escapeQuotes("ab\"c"), "ab\\\"c"); Assert.assertEquals(StringUtil.escapeQuotes("ab\\\"c"), "ab\\\\\\\"c"); Assert.assertEquals(StringUtil.escapeQuotes("ab\\\\\"c"), "ab\\\\\\\\\\\"c"); } |
StringUtil { public static String unescapeQuotes(String s) { StringBuilder sb = new StringBuilder(s.length()); try { unescapeQuotes(s, sb); } catch (IOException e) { LOGGER.error("Could not unescape quotes", e); } return sb.toString(); } private StringUtil(); static String enquote(String s); static void enquote(String s, Appendable a); static Pattern getIdentifierPattern(); static String enquoteIfNecessary(String s); static void enquoteIfNecessary(String s, Appendable a); static String enquoteIfNecessary(String s, Pattern p); static void enquoteIfNecessary(String s, Appendable a, Pattern valid); static void enquoteIfNecessary(String s, Appendable a, Pattern valid, Pattern exception); static String unquote(String s); static void unquote(String s, Appendable a); static String unescapeQuotes(String s); static void unescapeQuotes(String s, Appendable a); static String escapeQuotes(String s); static void escapeQuotes(String s, Appendable a); static void appendArray(Appendable a, Object[] array, String sepString); static void appendArrayEnquoted(Appendable a, Object[] array, String sepString); static void appendIterable(Appendable a, Iterable<?> it, String sepString); static void appendIterableEnquoted(Appendable a, Iterable<?> it, String sepString); static void appendObject(Appendable a, @Nullable Object obj); } | @Test public void testUnescapeQuotes() { Assert.assertEquals(StringUtil.unescapeQuotes(""), ""); Assert.assertEquals(StringUtil.unescapeQuotes("abc"), "abc"); Assert.assertEquals(StringUtil.unescapeQuotes("\"abc\""), "\"abc\""); Assert.assertEquals(StringUtil.unescapeQuotes("\\\"abc\\\""), "\"abc\""); Assert.assertEquals(StringUtil.unescapeQuotes("ab\"c"), "ab\"c"); Assert.assertEquals(StringUtil.unescapeQuotes("ab\\\"c"), "ab\"c"); Assert.assertEquals(StringUtil.unescapeQuotes("ab\\\\\"c"), "ab\\\"c"); Assert.assertEquals(StringUtil.unescapeQuotes("ab\\\\c"), "ab\\c"); } |
IOUtil { public static Writer asBufferedUTF8Writer(final File file) throws IOException { return Files.newBufferedWriter(file.toPath(), StandardCharsets.UTF_8); } private IOUtil(); static InputStream asUncompressedInputStream(InputStream is); static InputStream asBufferedInputStream(InputStream is); static InputStream asBufferedInputStream(File file); static OutputStream asBufferedOutputStream(OutputStream os); static OutputStream asBufferedOutputStream(File file); static Reader asBufferedUTF8Reader(final File file); static Reader asBufferedUTF8Reader(final InputStream is); static Reader asUTF8Reader(final InputStream is); static Writer asBufferedUTF8Writer(final File file); static Writer asBufferedUTF8Writer(final OutputStream os); static Writer asUTF8Writer(final OutputStream os); static InputStream asUncompressedBufferedNonClosingInputStream(InputStream is); static Reader asUncompressedBufferedNonClosingUTF8Reader(final InputStream is); static OutputStream asBufferedNonClosingOutputStream(OutputStream os); static Writer asBufferedNonClosingUTF8Writer(final OutputStream os); } | @Test public void uncompressedInputStreamTest() throws IOException { final String msg = "Hello World"; try (ByteArrayOutputStream plain = new ByteArrayOutputStream(); ByteArrayOutputStream compressed = new ByteArrayOutputStream()) { try (Writer plainWriter = IOUtil.asBufferedUTF8Writer(plain); Writer compressedWriter = IOUtil.asBufferedUTF8Writer(new GZIPOutputStream(compressed))) { plainWriter.append(msg); compressedWriter.append(msg); } try (BufferedReader plainReader = buildReader(plain.toByteArray()); BufferedReader compressedReader = buildReader(compressed.toByteArray())) { Assert.assertEquals(plainReader.readLine(), msg); Assert.assertEquals(compressedReader.readLine(), msg); } } } |
RandomUtil { public <T> @Nullable T choose(T[] array) { return choose(array, random); } RandomUtil(); RandomUtil(Random random); T choose(T[] array); static T choose(T[] array, Random rand); T choose(List<? extends T> list); static T choose(List<? extends T> list, Random rand); Random getRandom(); int[] distinctIntegers(int num, int min, int max); static int[] distinctIntegers(int num, int min, int max, Random rand); int[] distinctIntegers(int num, int max); static int[] distinctIntegers(int num, int max, Random rand); List<T> sample(List<? extends T> list, int num); static List<T> sample(List<? extends T> list, int num, Random rand); List<T> sampleUnique(List<? extends T> list, int num); static List<T> sampleUnique(List<? extends T> list, int num, Random rand); } | @Test public void testChooseArray() { Assert.assertNull(util.choose(new Object[0])); Assert.assertEquals(util.choose(new Object[] {1}), 1); final Integer chosenElement = util.choose(array); Assert.assertNotNull(chosenElement); Assert.assertTrue(0 <= chosenElement && chosenElement < HIGH); }
@Test public void testChooseList() { Assert.assertNull(util.choose(Collections.emptyList())); Assert.assertEquals(util.choose(Collections.singletonList(1)), (Integer) 1); final Integer chosenElement = util.choose(list); Assert.assertNotNull(chosenElement); Assert.assertTrue(0 <= chosenElement && chosenElement < HIGH); } |
MealyMachines { public static <I, O> CompactMealy<I, O> complete(MealyMachine<?, I, ?, O> mealy, Alphabet<I> inputs, O undefinedOutput) { return complete(mealy, inputs, undefinedOutput, new CompactMealy<>(inputs)); } private MealyMachines(); static CompactMealy<I, Pair<O1, O2>> combine(MealyMachine<?, I, ?, O1> mealy1,
MealyMachine<?, I, ?, O2> mealy2,
Alphabet<I> inputAlphabet); static A combine(MealyMachine<?, I, ?, O1> mealy1,
MealyMachine<?, I, ?, O2> mealy2,
Collection<? extends I> inputs,
A out); static CompactMealy<I, O> complete(MealyMachine<?, I, ?, O> mealy,
Alphabet<I> inputs,
O undefinedOutput); static A complete(MealyMachine<?, I, ?, O> mealy,
Collection<? extends I> inputs,
O undefinedOutput,
A out); } | @Test public void testCompletion() { final CompactMealy<Character, Integer> completed = MealyMachines.complete(mealy1, alphabet, -1); final Word<Character> originalInput = Word.fromCharSequence("abcabcabc"); final Word<Character> partialInput = Word.fromCharSequence("abcbbb"); final Word<Character> undefinedInput = Word.fromCharSequence("bbbbbb"); final Word<Integer> originalOutput = completed.computeOutput(originalInput); final Word<Integer> partialOutput = completed.computeOutput(partialInput); final Word<Integer> undefinedOutput = completed.computeOutput(undefinedInput); Assert.assertEquals(completed.size(), mealy1.size() + 1); Assert.assertEquals(originalOutput, Word.fromSymbols(1, 2, 3, 1, 2, 3, 1, 2, 3)); Assert.assertEquals(partialOutput, Word.fromSymbols(1, 2, 3, -1, -1, -1)); Assert.assertEquals(undefinedOutput, Word.fromSymbols(-1, -1, -1, -1, -1, -1)); } |
RandomUtil { public int[] distinctIntegers(int num, int min, int max) { return distinctIntegers(num, min, max, random); } RandomUtil(); RandomUtil(Random random); T choose(T[] array); static T choose(T[] array, Random rand); T choose(List<? extends T> list); static T choose(List<? extends T> list, Random rand); Random getRandom(); int[] distinctIntegers(int num, int min, int max); static int[] distinctIntegers(int num, int min, int max, Random rand); int[] distinctIntegers(int num, int max); static int[] distinctIntegers(int num, int max, Random rand); List<T> sample(List<? extends T> list, int num); static List<T> sample(List<? extends T> list, int num, Random rand); List<T> sampleUnique(List<? extends T> list, int num); static List<T> sampleUnique(List<? extends T> list, int num, Random rand); } | @Test public void testDistinctIntegers() { Assert.assertEquals(util.distinctIntegers(0, HIGH).length, 0); int[] result = util.distinctIntegers(HIGH, HIGH); util.distinctIntegers(HIGH, HIGH); Assert.assertEquals(result.length, HIGH); Arrays.sort(result); Assert.assertEquals(box(result), array); result = util.distinctIntegers(HIGH, HIGH / 2); Assert.assertEquals(result.length, HIGH / 2); Arrays.sort(result); Assert.assertEquals(box(result), Arrays.copyOfRange(array, 0, HIGH / 2)); result = util.distinctIntegers(HIGH, HIGH / 2, HIGH); Assert.assertEquals(result.length, HIGH / 2); Arrays.sort(result); Assert.assertEquals(box(result), Arrays.copyOfRange(array, HIGH / 2, HIGH)); result = util.distinctIntegers(HIGH - 1, HIGH); Assert.assertEquals(result.length, HIGH - 1); Assert.assertEquals(new HashSet<>(Arrays.asList(box(result))).size(), HIGH - 1); Assert.assertTrue(Arrays.asList(array).containsAll(Arrays.asList(box(result)))); } |
RandomUtil { public <T> List<T> sampleUnique(List<? extends T> list, int num) { return sampleUnique(list, num, random); } RandomUtil(); RandomUtil(Random random); T choose(T[] array); static T choose(T[] array, Random rand); T choose(List<? extends T> list); static T choose(List<? extends T> list, Random rand); Random getRandom(); int[] distinctIntegers(int num, int min, int max); static int[] distinctIntegers(int num, int min, int max, Random rand); int[] distinctIntegers(int num, int max); static int[] distinctIntegers(int num, int max, Random rand); List<T> sample(List<? extends T> list, int num); static List<T> sample(List<? extends T> list, int num, Random rand); List<T> sampleUnique(List<? extends T> list, int num); static List<T> sampleUnique(List<? extends T> list, int num, Random rand); } | @Test public void testSampleUnique() { Assert.assertEquals(util.sampleUnique(Collections.emptyList(), HIGH), Collections.emptyList()); List<Integer> result = util.sampleUnique(list, HIGH); Assert.assertEquals(result.size(), HIGH); result.sort(Integer::compareTo); Assert.assertEquals(result, list); result = util.sampleUnique(list, HIGH - 1); Assert.assertEquals(result.size(), HIGH - 1); Assert.assertEquals(new HashSet<>(result).size(), HIGH - 1); Assert.assertTrue(list.containsAll(result)); } |
RandomUtil { public <T> List<T> sample(List<? extends T> list, int num) { return sample(list, num, random); } RandomUtil(); RandomUtil(Random random); T choose(T[] array); static T choose(T[] array, Random rand); T choose(List<? extends T> list); static T choose(List<? extends T> list, Random rand); Random getRandom(); int[] distinctIntegers(int num, int min, int max); static int[] distinctIntegers(int num, int min, int max, Random rand); int[] distinctIntegers(int num, int max); static int[] distinctIntegers(int num, int max, Random rand); List<T> sample(List<? extends T> list, int num); static List<T> sample(List<? extends T> list, int num, Random rand); List<T> sampleUnique(List<? extends T> list, int num); static List<T> sampleUnique(List<? extends T> list, int num, Random rand); } | @Test public void testSampleList() { Assert.assertEquals(util.sample(Collections.emptyList(), HIGH), Collections.emptyList()); List<Integer> result = util.sample(list, HIGH); Assert.assertEquals(result.size(), HIGH); Assert.assertTrue(list.containsAll(result)); result = util.sample(list, HIGH * 2); Assert.assertEquals(result.size(), HIGH * 2); Assert.assertTrue(list.containsAll(result)); } |
ReflectUtil { public static <T> @Nullable Constructor<T> findConstructor(Class<T> clazz, Class<?>... params) { try { return clazz.getConstructor(params); } catch (NoSuchMethodException e) { @SuppressWarnings("unchecked") Constructor<T>[] ctors = (Constructor<T>[]) clazz.getConstructors(); for (Constructor<T> candidate : ctors) { if (w2pEquals(candidate.getParameterTypes(), params)) { return candidate; } } return null; } } private ReflectUtil(); static Constructor<T> findConstructor(Class<T> clazz, Class<?>... params); static @Nullable Method findMethod(Class<?> clazz, String name, Class<?>... params); static @Nullable Method findMatchingMethod(Class<?> clazz, String name, @Nullable Object... args); static @Nullable Method findMethodRT(Class<?> clazz,
String name,
@Nullable Class<?> returnType,
Class<?>... params); } | @Test public void testConstructors() { @SuppressWarnings("unchecked") final Constructor<TestClass> actualConstructor = (Constructor<TestClass>) TestClass.class.getConstructors()[0]; final Constructor<TestClass> constructor1 = ReflectUtil.findConstructor(TestClass.class, SIGNATURE_1); final Constructor<TestClass> constructor2 = ReflectUtil.findConstructor(TestClass.class, SIGNATURE_2); final Constructor<TestClass> constructor3 = ReflectUtil.findConstructor(TestClass.class, SIGNATURE_3); final Constructor<TestClass> constructor4 = ReflectUtil.findConstructor(TestClass.class, SIGNATURE_4); Assert.assertEquals(constructor1, actualConstructor); Assert.assertEquals(constructor2, actualConstructor); Assert.assertEquals(constructor3, actualConstructor); Assert.assertNull(constructor4); } |
ReflectUtil { public static @Nullable Method findMethod(Class<?> clazz, String name, Class<?>... params) { try { return clazz.getMethod(name, params); } catch (NoSuchMethodException e) { Method[] methods = clazz.getMethods(); for (Method candidate : methods) { if (candidate.getName().equals(name) && w2pEquals(candidate.getParameterTypes(), params)) { return candidate; } } return null; } } private ReflectUtil(); static Constructor<T> findConstructor(Class<T> clazz, Class<?>... params); static @Nullable Method findMethod(Class<?> clazz, String name, Class<?>... params); static @Nullable Method findMatchingMethod(Class<?> clazz, String name, @Nullable Object... args); static @Nullable Method findMethodRT(Class<?> clazz,
String name,
@Nullable Class<?> returnType,
Class<?>... params); } | @Test public void testMethod() { final Method method1 = ReflectUtil.findMethod(TestClass.class, methodName, SIGNATURE_1); final Method method2 = ReflectUtil.findMethod(TestClass.class, methodName, SIGNATURE_2); final Method method3 = ReflectUtil.findMethod(TestClass.class, methodName, SIGNATURE_3); final Method method4 = ReflectUtil.findMethod(TestClass.class, methodName, SIGNATURE_4); final Method method5 = ReflectUtil.findMethod(TestClass.class, "randomName", SIGNATURE_1); Assert.assertEquals(method1, methodToFind); Assert.assertEquals(method2, methodToFind); Assert.assertEquals(method3, methodToFind); Assert.assertNull(method4); Assert.assertNull(method5); } |
ReflectUtil { public static @Nullable Method findMatchingMethod(Class<?> clazz, String name, @Nullable Object... args) { for (Method m : clazz.getMethods()) { if (!m.getName().equals(name)) { continue; } if (isMatch(m.getParameterTypes(), args)) { return m; } } return null; } private ReflectUtil(); static Constructor<T> findConstructor(Class<T> clazz, Class<?>... params); static @Nullable Method findMethod(Class<?> clazz, String name, Class<?>... params); static @Nullable Method findMatchingMethod(Class<?> clazz, String name, @Nullable Object... args); static @Nullable Method findMethodRT(Class<?> clazz,
String name,
@Nullable Class<?> returnType,
Class<?>... params); } | @Test public void testMethodByArgs() { final Method method1 = ReflectUtil.findMatchingMethod(TestClass.class, methodName, 1, Boolean.TRUE, 'c', (byte) 3); final Method method2 = ReflectUtil.findMatchingMethod(TestClass.class, methodName, 1, null, 'c', (byte) 3); final Method method3 = ReflectUtil.findMatchingMethod(TestClass.class, methodName, 1, true, null, null); final Method method4 = ReflectUtil.findMatchingMethod(TestClass.class, methodName, 4L, false); final Method method5 = ReflectUtil.findMatchingMethod(TestClass.class, "randomName", 1, true, 'c', (byte) 3); Assert.assertEquals(method1, methodToFind); Assert.assertEquals(method2, methodToFind); Assert.assertNull(method3); Assert.assertNull(method4); Assert.assertNull(method5); } |
ReflectUtil { public static @Nullable Method findMethodRT(Class<?> clazz, String name, @Nullable Class<?> returnType, Class<?>... params) { Method m = findMethod(clazz, name, params); if (m == null) { return null; } else if (returnType == null) { return m; } Class<?> rt = m.getReturnType(); if (w2pEquals(rt, returnType) || returnType.isAssignableFrom(rt)) { return m; } return null; } private ReflectUtil(); static Constructor<T> findConstructor(Class<T> clazz, Class<?>... params); static @Nullable Method findMethod(Class<?> clazz, String name, Class<?>... params); static @Nullable Method findMatchingMethod(Class<?> clazz, String name, @Nullable Object... args); static @Nullable Method findMethodRT(Class<?> clazz,
String name,
@Nullable Class<?> returnType,
Class<?>... params); } | @Test public void testMethodWithReturnType() { final Method method1 = ReflectUtil.findMethodRT(TestClass.class, methodName, null, SIGNATURE_1); final Method method2 = ReflectUtil.findMethodRT(TestClass.class, methodName, Void.class, SIGNATURE_1); final Method method3 = ReflectUtil.findMethodRT(TestClass.class, methodName, Integer.class, SIGNATURE_1); Assert.assertEquals(method1, methodToFind); Assert.assertEquals(method2, methodToFind); Assert.assertNull(method3); final Method method4 = ReflectUtil.findMethodRT(TestClass.class, methodName, null, SIGNATURE_2); final Method method5 = ReflectUtil.findMethodRT(TestClass.class, methodName, Void.class, SIGNATURE_2); final Method method6 = ReflectUtil.findMethodRT(TestClass.class, methodName, Integer.class, SIGNATURE_2); Assert.assertEquals(method4, methodToFind); Assert.assertEquals(method5, methodToFind); Assert.assertNull(method6); final Method method7 = ReflectUtil.findMethodRT(TestClass.class, methodName, null, SIGNATURE_4); final Method method8 = ReflectUtil.findMethodRT(TestClass.class, methodName, Void.class, SIGNATURE_4); final Method method9 = ReflectUtil.findMethodRT(TestClass.class, methodName, Integer.class, SIGNATURE_4); Assert.assertNull(method7); Assert.assertNull(method8); Assert.assertNull(method9); final Method method10 = ReflectUtil.findMethodRT(TestClass.class, "randomName", null, SIGNATURE_1); final Method method11 = ReflectUtil.findMethodRT(TestClass.class, "randomName", Void.class, SIGNATURE_1); final Method method12 = ReflectUtil.findMethodRT(TestClass.class, "randomName", Integer.class, SIGNATURE_1); Assert.assertNull(method10); Assert.assertNull(method11); Assert.assertNull(method12); } |
BackedGeneralPriorityQueue extends AbstractSmartCollection<E> implements SmartGeneralPriorityQueue<E, K> { @Override public E extractMin() { Entry<E, K> min = backingQueue.extractMin(); return min.element; } BackedGeneralPriorityQueue(); BackedGeneralPriorityQueue(int initialCapacity); BackedGeneralPriorityQueue(List<? extends E> init, List<K> keys); BackedGeneralPriorityQueue(Supplier<? extends SmartDynamicPriorityQueue<Entry<E, K>>> supplier); BackedGeneralPriorityQueue(SmartDynamicPriorityQueue<Entry<E, K>> backingQueue); @Override E choose(); @Override ElementReference chooseRef(); @Override @Nullable ElementReference find(@Nullable Object element); @Override void quickClear(); @Override void deepClear(); @SuppressWarnings("nullness") // function is only called on elements of the iterator for which we know non-nullness @Override Iterator<E> iterator(); @Override E get(ElementReference ref); @Override ElementReference referencedAdd(E elem); @Override ElementReference add(E elem, @Nullable K key); @Override void setDefaultKey(K defaultKey); @Override void changeKey(ElementReference ref, K newKey); @Override void remove(ElementReference ref); @Override Iterator<ElementReference> referenceIterator(); @Override void replace(ElementReference ref, E newElement); @Override int size(); @Override boolean isEmpty(); @Override void clear(); @Override E peekMin(); @Override E extractMin(); } | @Test public void testExtractMin() { for (int i = 0; i < 5; i++) { Assert.assertEquals(this.queue.extractMin(), Character.valueOf((char) ('j' - i))); } } |
UnorderedCollection extends AbstractSmartCollection<E> implements CapacityManagement { @Override public <T extends E> void addAll(T[] array) { ensureCapacity(size + array.length); for (T t : array) { storage.array[size] = new Reference<>(t, size); size++; } } UnorderedCollection(); UnorderedCollection(int initialCapacity); @SuppressWarnings("initialization") // addAll only access initialized data structures UnorderedCollection(Collection<? extends E> coll); @Override boolean ensureCapacity(int minCapacity); @Override boolean ensureAdditionalCapacity(int additionalSpace); @Override void hintNextCapacity(int nextCapacityHint); @Override E get(ElementReference ref); @Override ElementReference referencedAdd(E elem); @Override void remove(ElementReference ref); @Override Iterator<ElementReference> referenceIterator(); @Override void replace(ElementReference ref, E newElement); @Override E choose(); @Override ElementReference chooseRef(); @Override Iterable<ElementReference> references(); @Override void addAll(T[] array); @Override boolean addAll(Collection<? extends E> coll); @Override void quickClear(); @SuppressWarnings("nullness") // setting 'null' is fine, when (according to JavaDoc) calling quickClear() first @Override void deepClear(); @Override Iterator<E> iterator(); @Override int size(); @Override boolean isEmpty(); @SuppressWarnings("nullness") // setting 'null' is fine, because we also decrease the size @Override void clear(); void swap(UnorderedCollection<E> other); } | @Test public void testAddArray() { this.collection.addAll(new Integer[] {1, 1, 1}); }
@Test public void testAddCollection() { this.collection.addAll(Arrays.asList(2, 2, 2)); }
@Test public void testAddIterable() { this.collection.addAll((Iterable<Integer>) Arrays.asList(3, 3, 3)); } |
Automata extends TS { public static <S, I> Iterable<TransRef<S, I, ?>> allDefinedInputs(Automaton<S, I, ?> automaton, Iterable<? extends I> inputs) { return allDefinedInputs(automaton, automaton, inputs); } static Graph<S, TransitionEdge<I, T>> asGraph(Automaton<S, I, T> automaton,
Collection<? extends I> inputs); static A minimize(
UniversalDeterministicAutomaton<S, I, T, SP, TP> automaton,
Collection<? extends I> inputs,
A output); static UniversalGraph<S, TransitionEdge<I, T>, SP, TransitionEdge.Property<I, TP>> asUniversalGraph(
UniversalAutomaton<S, I, T, SP, TP> automaton,
Collection<? extends I> inputs); @SuppressWarnings("unchecked") static A invasiveMinimize(A automaton,
Collection<? extends I> inputs); static Word<I> findShortestSeparatingWord(UniversalDeterministicAutomaton<?, I, ?, ?, ?> reference,
UniversalDeterministicAutomaton<?, I, ?, ?, ?> other,
Collection<? extends I> inputs); static boolean testEquivalence(UniversalDeterministicAutomaton<?, I, ?, ?, ?> reference,
UniversalDeterministicAutomaton<?, I, ?, ?, ?> other,
Collection<? extends I> inputs); static boolean testEquivalence(final OneSEVPA<?, I> sevpa1,
final OneSEVPA<?, I> sevpa2,
final VPDAlphabet<I> inputs); static Word<I> findSeparatingWord(UniversalDeterministicAutomaton<?, I, ?, ?, ?> reference,
UniversalDeterministicAutomaton<?, I, ?, ?, ?> other,
Collection<? extends I> inputs); static Word<I> findSeparatingWord(UniversalDeterministicAutomaton<S, I, ?, ?, ?> automaton,
S state1,
S state2,
Collection<? extends I> inputs); static Word<I> findSeparatingWord(final OneSEVPA<?, I> sevpa1,
final OneSEVPA<?, I> sevpa2,
final VPDAlphabet<I> inputs); static List<Word<I>> characterizingSet(UniversalDeterministicAutomaton<?, I, ?, ?, ?> automaton,
Collection<? extends I> inputs); static void characterizingSet(UniversalDeterministicAutomaton<?, I, ?, ?, ?> automaton,
Collection<? extends I> inputs,
Collection<? super Word<I>> result); static boolean incrementalCharacterizingSet(UniversalDeterministicAutomaton<?, I, ?, ?, ?> automaton,
Collection<? extends I> inputs,
Collection<? extends Word<I>> oldSuffixes,
Collection<? super Word<I>> newSuffixes); static List<Word<I>> stateCharacterizingSet(UniversalDeterministicAutomaton<S, I, ?, ?, ?> automaton,
Collection<? extends I> inputs,
S state); static void stateCharacterizingSet(UniversalDeterministicAutomaton<S, I, ?, ?, ?> automaton,
Collection<? extends I> inputs,
S state,
Collection<? super Word<I>> result); static List<Word<I>> stateCover(DeterministicAutomaton<?, I, ?> automaton,
Collection<? extends I> inputs); static List<Word<I>> transitionCover(DeterministicAutomaton<?, I, ?> automaton,
Collection<? extends I> inputs); static List<Word<I>> structuralCover(DeterministicAutomaton<?, I, ?> automaton,
Collection<? extends I> inputs); static Iterator<TransRef<S, I, ?>> allDefinedInputsIterator(Automaton<S, I, ?> automaton,
Iterable<? extends I> inputs); static Iterable<TransRef<S, I, ?>> allDefinedInputs(Automaton<S, I, ?> automaton,
Iterable<? extends I> inputs); static Iterable<TransRef<S, I, ?>> allUndefinedInputs(Automaton<S, I, ?> automaton,
Iterable<? extends I> inputs); static boolean hasUndefinedInput(Automaton<?, I, ?> automaton, Iterable<? extends I> inputs); static TransRef<S, I, ?> findUndefinedInput(Automaton<S, I, ?> automaton,
Iterable<? extends I> inputs); static Iterator<TransRef<S, I, ?>> allUndefinedInputsIterator(Automaton<S, I, ?> automaton,
Iterable<? extends I> inputs); } | @Test public void testAllDefinedInputsPartial() { final Iterable<TransRef<Integer, Character, ?>> trans = Automata.allDefinedInputs(this.partial, this.alphabet); int definedCount = 0; for (TransRef<Integer, Character, ?> t : trans) { Assert.assertNotNull(t.transition); Assert.assertNotNull(this.partial.getSuccessor(t.state, t.input)); definedCount++; } Assert.assertEquals(definedCount, 5); }
@Test public void testAllDefinedInputsComplete() { final Iterable<TransRef<Integer, Character, ?>> trans = Automata.allDefinedInputs(this.complete, this.alphabet); int definedCount = 0; for (TransRef<Integer, Character, ?> t : trans) { Assert.assertNotNull(t.transition); Assert.assertNotNull(this.complete.getSuccessor(t.state, t.input)); definedCount++; } Assert.assertEquals(definedCount, this.complete.size() * this.alphabet.size()); } |
UnorderedCollection extends AbstractSmartCollection<E> implements CapacityManagement { @Override public void remove(ElementReference ref) { remove(extractValidIndex(ref)); } UnorderedCollection(); UnorderedCollection(int initialCapacity); @SuppressWarnings("initialization") // addAll only access initialized data structures UnorderedCollection(Collection<? extends E> coll); @Override boolean ensureCapacity(int minCapacity); @Override boolean ensureAdditionalCapacity(int additionalSpace); @Override void hintNextCapacity(int nextCapacityHint); @Override E get(ElementReference ref); @Override ElementReference referencedAdd(E elem); @Override void remove(ElementReference ref); @Override Iterator<ElementReference> referenceIterator(); @Override void replace(ElementReference ref, E newElement); @Override E choose(); @Override ElementReference chooseRef(); @Override Iterable<ElementReference> references(); @Override void addAll(T[] array); @Override boolean addAll(Collection<? extends E> coll); @Override void quickClear(); @SuppressWarnings("nullness") // setting 'null' is fine, when (according to JavaDoc) calling quickClear() first @Override void deepClear(); @Override Iterator<E> iterator(); @Override int size(); @Override boolean isEmpty(); @SuppressWarnings("nullness") // setting 'null' is fine, because we also decrease the size @Override void clear(); void swap(UnorderedCollection<E> other); } | @Test(dependsOnMethods = {"testAddArray", "testAddCollection", "testAddIterable"}) public void testRemove() { Assert.assertTrue(this.collection.remove(0)); Assert.assertTrue(this.collection.remove(1)); Assert.assertTrue(this.collection.remove(2)); Assert.assertTrue(this.collection.remove(3)); } |
DOTFrame extends JFrame { public void addGraph(String name, Reader dotText) throws IOException { dotPanel.addGraph(name, dotText); } DOTFrame(); DOTFrame(String title); void addGraph(String name, Reader dotText); void addGraph(String name, String dotText); } | @Test(timeOut = 30000) public void testFrame() throws InvocationTargetException, InterruptedException { if (JVMUtil.getCanonicalSpecVersion() > 8) { throw new SkipException("The headless AWT environment currently only works with Java 8 and below"); } final Random random = new Random(42); SwingUtilities.invokeAndWait(() -> { final DOTFrame frame = new DOTFrame(); frame.addGraph("1", TestUtil.generateRandomAutomatonDot(random)); frame.addGraph("2", TestUtil.generateRandomAutomatonDot(random)); try { frame.addGraph("3", new StringReader(TestUtil.generateRandomAutomatonDot(random))); } catch (IOException e) { throw new RuntimeException(e); } frame.setVisible(true); }); } |
BricsDFA extends AbstractBricsAutomaton implements DFA<State, Character> { @Override public State getInitialState() { return automaton.getInitialState(); } BricsDFA(Automaton automaton); BricsDFA(Automaton automaton, boolean totalize); @Override State getInitialState(); @Override State getSuccessor(State state, Character input); @Override State getTransition(State state, Character input); } | @Test public void testStructuralEquality() { AbstractBricsAutomaton.GraphView graphView = dfa.graphView(); Assert.assertEquals(dfa.getInitialState(), bricsAutomaton.getInitialState()); Set<State> states1 = new HashSet<>(bricsAutomaton.getStates()); Set<State> states2 = new HashSet<>(dfa.getStates()); Assert.assertEquals(states1, states2); for (State s : dfa) { Assert.assertEquals(dfa.isAccepting(s), s.isAccept()); Set<Transition> trans1 = new HashSet<>(graphView.getOutgoingEdges(s)); Set<Transition> trans2 = new HashSet<>(s.getTransitions()); Assert.assertEquals(trans1, trans2); } } |
FSM2MealyParserAlternating extends AbstractFSM2MealyParser<I, O> { public static <I, O> FSM2MealyParserAlternating<I, O> getParser(@Nullable Collection<? extends I> targetInputs, @Nullable Output<I, Word<O>> output, Function<String, I> inputParser, Function<String, O> outputParser) { return new FSM2MealyParserAlternating<>(targetInputs, output, inputParser, outputParser); } private FSM2MealyParserAlternating(@Nullable Collection<? extends I> targetInputs,
@Nullable Output<I, Word<O>> output,
Function<String, I> inputParser,
Function<String, O> outputParser); static FSM2MealyParserAlternating<I, O> getParser(@Nullable Collection<? extends I> targetInputs,
@Nullable Output<I, Word<O>> output,
Function<String, I> inputParser,
Function<String, O> outputParser); static FSM2MealyParserAlternating<I, O> getParser(Function<String, I> inputParser,
Function<String, O> outputParser); static FSM2MealyParserAlternating<E, E> getParser(@Nullable Collection<? extends E> targetInputs,
@Nullable Output<E, Word<E>> output,
Function<String, E> edgeParser); static FSM2MealyParserAlternating<E, E> getParser(Function<String, E> edgeParser); static final String PARTIAL_FSM; static final String INPUT_HAS_NO_OUTPUT; } | @Test public void testParse() throws Exception { try (InputStream is = FSM2MealyParserAlternatingTest.class.getResourceAsStream("/MealyAlternating.fsm")) { final Function<String, Character> ep = s -> s.charAt(0); final CompactMealy<Character, Character> actualMealy = FSM2MealyParserAlternating.getParser(ep).readModel(is); final Alphabet<Character> alphabet = Alphabets.characters('a', 'a'); CompactMealy<Character, ?> expectedMealy = AutomatonBuilders.newMealy(alphabet) .from("q0").on('a').withOutput('1').to("q1") .from("q1").on('a').withOutput('2').to("q0") .withInitial("q0") .create(); Assert.assertTrue(Automata.testEquivalence(actualMealy, expectedMealy, alphabet)); } }
@Test public void doNotCloseInputStreamTest() throws IOException { try (InputStream is = FSM2MealyParserAlternatingTest.class.getResourceAsStream("/MealyAlternating.fsm")) { FSM2MealyParserAlternating.getParser(s -> s.charAt(0)).readModel(new UnclosableInputStream(is)); } } |
FSM2MealyParserIO extends AbstractFSM2MealyParser<I, O> { public static <I, O> FSM2MealyParserIO<I, O> getParser(@Nullable Collection<? extends I> targetInputs, Function<String, I> inputParser, Function<String, O> outputParser) { return new FSM2MealyParserIO<>(targetInputs, inputParser, outputParser); } private FSM2MealyParserIO(@Nullable Collection<? extends I> targetInputs,
Function<String, I> inputParser,
Function<String, O> outputParser); static FSM2MealyParserIO<I, O> getParser(@Nullable Collection<? extends I> targetInputs,
Function<String, I> inputParser,
Function<String, O> outputParser); static FSM2MealyParserIO<I, O> getParser(Function<String, I> inputParser,
Function<String, O> outputParser); static FSM2MealyParserIO<E, E> getParser(@Nullable Collection<? extends E> targetInputs,
Function<String, E> edgeParser); static FSM2MealyParserIO<E, E> getParser(Function<String, E> edgeParser); } | @Test public void testParse() throws Exception { try (InputStream is = FSM2MealyParserIOTest.class.getResourceAsStream("/MealyIO.fsm")) { final Function<String, Character> ep = s -> s.charAt(0); final CompactMealy<Character, Character> actualMealy = FSM2MealyParserIO.getParser(ep).readModel(is); final Alphabet<Character> alphabet = Alphabets.characters('a', 'a'); CompactMealy<Character, ?> expectedMealy = AutomatonBuilders.newMealy(alphabet) .from("q0").on('a').withOutput('1').to("q1") .from("q1").on('a').withOutput('2').to("q0") .withInitial("q0") .create(); Assert.assertTrue(Automata.testEquivalence(actualMealy, expectedMealy, alphabet)); } }
@Test public void doNotCloseInputStreamTest() throws IOException { try (InputStream is = FSM2MealyParserIOTest.class.getResourceAsStream("/MealyIO.fsm")) { FSM2MealyParserIO.getParser(s -> s.charAt(0)).readModel(new UnclosableInputStream(is)); } } |
FSM2DFAParser extends AbstractFSMParser<I> implements ModelDeserializer<CompactDFA<I>> { @Override public CompactDFA<I> readModel(InputStream is) throws IOException { try (Reader r = IOUtil.asUncompressedBufferedNonClosingUTF8Reader(is)) { return parseDFA(r); } } private FSM2DFAParser(@Nullable Collection<? extends I> targetInputs,
Function<String, I> inputParser,
String acceptingDataVariableName,
String acceptingDataValue); @Override CompactDFA<I> readModel(InputStream is); static FSM2DFAParser<I> getParser(@Nullable Collection<? extends I> targetInputs,
Function<String, I> inputParser,
String acceptingDataVariableName,
String acceptingDataValue); static FSM2DFAParser<I> getParser(Function<String, I> inputParser,
String acceptingDataVariableName,
String acceptingDataValue); static final String ACCEPT_NOT_FOUND; static final String ACCEPT_VALUE_NOT_FOUND; static final String ACCEPT_INDEX_NOT_FOUND; } | @Test public void testParse1() throws Exception { try (InputStream is = FSM2DFAParserTest.class.getResourceAsStream("/DFA1.fsm")) { final CompactDFA<Character> actualDFA = parser.readModel(is); final Alphabet<Character> alphabet = Alphabets.characters('a', 'b'); CompactDFA<Character> expectedDFA = AutomatonBuilders.newDFA(alphabet) .from("q0").on('a').to("q1") .from("q1").on('b').to("q0") .withAccepting("q1").withInitial("q0") .create(); Assert.assertTrue(Automata.testEquivalence(actualDFA, expectedDFA, alphabet)); } }
@Test public void testParse2() throws Exception { try (InputStream is = FSM2DFAParserTest.class.getResourceAsStream("/DFA2.fsm")) { final CompactDFA<Character> actualDFA = parser.readModel(is); final Alphabet<Character> alphabet = Alphabets.characters('a', 'a'); CompactDFA<Character> expectedDFA = AutomatonBuilders.newDFA(alphabet) .from("q0").on('a').loop() .withAccepting("q0").withInitial("q0") .create(); Assert.assertTrue(Automata.testEquivalence(actualDFA, expectedDFA, alphabet)); } }
@Test public void doNotCloseInputStreamTest() throws IOException { try (InputStream is = FSM2DFAParserTest.class.getResourceAsStream("/DFA1.fsm")) { parser.readModel(new UnclosableInputStream(is)); } } |
LTSminLTLDFA extends AbstractLTSminLTL<I, DFA<?, I>, DFALasso<I>> implements DFAModelCheckerLasso<I, String>, LTSminDFA<I, DFALasso<I>> { @Override public @Nullable DFALasso<I> findCounterExample(DFA<?, I> automaton, Collection<? extends I> inputs, String property) { final File fsm = findCounterExampleFSM(automaton, inputs, property); if (fsm == null) { return null; } try { final CompactDFA<I> dfa = FSM2DFAParser.getParser(inputs, getString2Input(), LABEL_NAME, LABEL_VALUE).readModel(fsm); return new DFALassoImpl<>(dfa, inputs, computeUnfolds(automaton.size())); } catch (IOException | FSMFormatException e) { throw new ModelCheckingException(e); } finally { if (!isKeepFiles() && !fsm.delete()) { LOGGER.warn("Could not delete file: " + fsm.getAbsolutePath()); } } } @GenerateBuilder(defaults = AbstractLTSminLTL.BuilderDefaults.class) LTSminLTLDFA(boolean keepFiles, Function<String, I> string2Input, int minimumUnfolds, double multiplier); @Override @Nullable DFALasso<I> findCounterExample(DFA<?, I> automaton, Collection<? extends I> inputs, String property); static final String LABEL_NAME; static final String LABEL_VALUE; } | @Test(expectedExceptions = ModelCheckingException.class) public void testPrefixClosed() { final DFA<?, String> dfa = AutomatonBuilders.newDFA(getAlphabet()). withInitial("q0").withAccepting("q1").from("q0").on("a").to("q1").create(); getModelChecker().findCounterExample(dfa, getAlphabet(), "true"); }
@Test(expectedExceptions = ModelCheckingException.class) public void testEmptyLanguage() { final DFA<?, String> dfa = AutomatonBuilders.newDFA(getAlphabet()). withInitial("q0").from("q0").on("a").loop().from("q0").on("b").loop().create(); getModelChecker().findCounterExample(dfa, getAlphabet(), "true"); } |
AbstractLTSminLTL extends AbstractLTSmin<I, A, L> implements ModelCheckerLasso<I, A, String, L> { @Override public void setMultiplier(double multiplier) { unfolder.setMultiplier(multiplier); } protected AbstractLTSminLTL(boolean keepFiles, Function<String, I> string2Input,
int minimumUnfolds, double multiplier); @Override double getMultiplier(); @Override void setMultiplier(double multiplier); @Override int getMinimumUnfolds(); @Override void setMinimumUnfolds(int minimumUnfolds); static final LTSminVersion REQUIRED_VERSION; } | @Test public void testComputeUnfolds() { Assert.assertEquals(getModelChecker().computeUnfolds(1), 3); getModelChecker().setMultiplier(2.0); Assert.assertEquals(getModelChecker().computeUnfolds(2), 4); }
@Test public void testSetMultiplier() { getModelChecker().setMultiplier(1337.0); Assert.assertEquals(getModelChecker().getMultiplier(), 1337.0, 0.0); }
@Test(expectedExceptions = IllegalArgumentException.class) public void testSetMultiplierExcept() { getModelChecker().setMultiplier(-1.0); } |
AbstractLTSminLTL extends AbstractLTSmin<I, A, L> implements ModelCheckerLasso<I, A, String, L> { @Override public void setMinimumUnfolds(int minimumUnfolds) { unfolder.setMinimumUnfolds(minimumUnfolds); } protected AbstractLTSminLTL(boolean keepFiles, Function<String, I> string2Input,
int minimumUnfolds, double multiplier); @Override double getMultiplier(); @Override void setMultiplier(double multiplier); @Override int getMinimumUnfolds(); @Override void setMinimumUnfolds(int minimumUnfolds); static final LTSminVersion REQUIRED_VERSION; } | @Test public void testSetMinimumUnfolds() { getModelChecker().setMinimumUnfolds(1337); Assert.assertEquals(getModelChecker().getMinimumUnfolds(), 1337); }
@Test(expectedExceptions = IllegalArgumentException.class) public void testSetMinimumUnfoldsExcept() { getModelChecker().setMinimumUnfolds(0); } |
LTSminMonitorDFA extends AbstractLTSminMonitor<I, DFA<?, I>, DFA<?, I>> implements LTSminDFA<I, DFA<?, I>> { @Override public @Nullable DFA<?, I> findCounterExample(DFA<?, I> automaton, Collection<? extends I> inputs, String property) { final File fsm = findCounterExampleFSM(automaton, inputs, property); if (fsm == null) { return null; } try { final CompactDFA<I> result = FSM2DFAParser.getParser(inputs, getString2Input(), LABEL_NAME, LABEL_VALUE).readModel(fsm); for (Integer state : result) { final boolean deadlocks = inputs.stream().noneMatch(i -> result.getSuccessor(state, i) != null); result.setAccepting(state, deadlocks); } return result; } catch (IOException | FSMFormatException e) { throw new ModelCheckingException(e); } finally { if (!isKeepFiles() && !fsm.delete()) { LOGGER.warn("Could not delete file: " + fsm.getAbsolutePath()); } } } @GenerateBuilder(defaults = BuilderDefaults.class) LTSminMonitorDFA(boolean keepFiles, Function<String, I> string2Input); @Override @Nullable DFA<?, I> findCounterExample(DFA<?, I> automaton, Collection<? extends I> inputs, String property); } | @Test(expectedExceptions = ModelCheckingException.class) public void testPrefixClosed() { final DFA<?, String> dfa = AutomatonBuilders.newDFA(getAlphabet()). withInitial("q0").withAccepting("q1").from("q0").on("a").to("q1").create(); getModelChecker().findCounterExample(dfa, getAlphabet(), "true"); }
@Test(expectedExceptions = ModelCheckingException.class) public void testEmptyLanguage() { final DFA<?, String> dfa = AutomatonBuilders.newDFA(getAlphabet()). withInitial("q0").from("q0").on("a").loop().from("q0").on("b").loop().create(); getModelChecker().findCounterExample(dfa, getAlphabet(), "true"); } |
Covers { private Covers() {} private Covers(); static void stateCover(DeterministicAutomaton<?, I, ?> automaton,
Collection<? extends I> inputs,
Collection<? super Word<I>> states); static Iterator<Word<I>> stateCoverIterator(DeterministicAutomaton<?, I, ?> automaton,
Collection<? extends I> inputs); static void transitionCover(DeterministicAutomaton<?, I, ?> automaton,
Collection<? extends I> inputs,
Collection<? super Word<I>> transitions); static Iterator<Word<I>> transitionCoverIterator(DeterministicAutomaton<?, I, ?> automaton,
Collection<? extends I> inputs); static void structuralCover(DeterministicAutomaton<?, I, ?> automaton,
Collection<? extends I> inputs,
Collection<? super Word<I>> cover); static void cover(DeterministicAutomaton<?, I, ?> automaton,
Collection<? extends I> inputs,
Collection<? super Word<I>> states,
Collection<? super Word<I>> transitions); static boolean incrementalStateCover(DeterministicAutomaton<S, I, ?> automaton,
Collection<? extends I> inputs,
Collection<? extends Word<I>> oldStates,
Collection<? super Word<I>> newStates); static Iterator<Word<I>> incrementalStateCoverIterator(DeterministicAutomaton<?, I, ?> automaton,
Collection<? extends I> inputs,
Collection<? extends Word<I>> stateCover); static boolean incrementalTransitionCover(DeterministicAutomaton<?, I, ?> automaton,
Collection<? extends I> inputs,
Collection<? extends Word<I>> oldTransCover,
Collection<? super Word<I>> newTransCover); static Iterator<Word<I>> incrementalTransitionCoverIterator(DeterministicAutomaton<?, I, ?> automaton,
Collection<? extends I> inputs,
Collection<? extends Word<I>> transitionCover); static boolean incrementalStructuralCover(DeterministicAutomaton<?, I, ?> automaton,
Collection<? extends I> inputs,
Collection<? extends Word<I>> oldCover,
Collection<? super Word<I>> newCover); static boolean incrementalCover(DeterministicAutomaton<?, I, ?> automaton,
Collection<? extends I> inputs,
Collection<? extends Word<I>> oldStateCover,
Collection<? extends Word<I>> oldTransCover,
Collection<? super Word<I>> newStateCover,
Collection<? super Word<I>> newTransCover); } | @Test public void testCovers() { final Random random = new Random(42); final Alphabet<Integer> alphabet = Alphabets.integers(0, 5); final DFA<?, Integer> dfa = RandomAutomata.randomDFA(random, 15, alphabet); testStateCover(dfa, Automata.stateCover(dfa, alphabet)); testTransitionCover(dfa, alphabet, Automata.transitionCover(dfa, alphabet)); } |
LTSminLTLParser { public static boolean isValidLetterFormula(String formula) { try { requireValidLetterFormula(formula); } catch (IllegalArgumentException iae) { LOGGER.debug("Couldn't parse formula", iae); return false; } return true; } private LTSminLTLParser(); static String requireValidLetterFormula(String formula); static boolean isValidLetterFormula(String formula); static String requireValidIOFormula(String formula); static boolean isValidIOFormula(String formula); } | @Test(dataProvider = "letter") public void testLetterFormulae(final String formula, boolean expectedValidity) { Assert.assertEquals(LTSminLTLParser.isValidLetterFormula(formula), expectedValidity); } |
LTSminLTLParser { public static boolean isValidIOFormula(String formula) { try { requireValidIOFormula(formula); } catch (IllegalArgumentException iae) { LOGGER.debug("Couldn't parse formula", iae); return false; } return true; } private LTSminLTLParser(); static String requireValidLetterFormula(String formula); static boolean isValidLetterFormula(String formula); static String requireValidIOFormula(String formula); static boolean isValidIOFormula(String formula); } | @Test(dataProvider = "io") public void testIOFormulae(final String formula, boolean expectedValidity) { Assert.assertEquals(LTSminLTLParser.isValidIOFormula(formula), expectedValidity); } |
LTSminVersion { public static LTSminVersion parse(String version) { final Matcher matcher = VERSION_PATTERN.matcher(version); if (matcher.find()) { final String major = matcher.group(1); final String minor = matcher.group(2); final String patch = matcher.group(3); if (major == null || minor == null || patch == null) { return fallback(version); } final LTSminVersion result = of(Integer.parseInt(major), Integer.parseInt(minor), Integer.parseInt(patch)); LOGGER.debug("Found version '{}'", version); LOGGER.debug("Parsed as '{}'", result); return result; } else { return fallback(version); } } private LTSminVersion(int major, int minor, int patch); static LTSminVersion of(int major, int minor, int patch); static LTSminVersion parse(String version); boolean supports(LTSminVersion required); @Override String toString(); @Override boolean equals(@Nullable Object o); @Override int hashCode(); } | @Test public void testParse() { final String v300 = "v3.0.0"; final String v300beta = "v3.0.0-beta1"; final String v300broken = "v3.0broken.0"; final String noV = "3.0.0"; final String prefixV = "prefixv3.0.0"; Assert.assertEquals(LTSminVersion.parse(v300), LTSminVersion.of(3, 0, 0)); Assert.assertEquals(LTSminVersion.parse(v300beta), LTSminVersion.of(3, 0, 0)); Assert.assertEquals(LTSminVersion.parse(v300broken), LTSminVersion.of(0, 0, 0)); Assert.assertEquals(LTSminVersion.parse(noV), LTSminVersion.of(0, 0, 0)); Assert.assertEquals(LTSminVersion.parse(prefixV), LTSminVersion.of(0, 0, 0)); } |
LTSminVersion { public boolean supports(LTSminVersion required) { if (major > required.major) { return true; } else if (major == required.major) { if (minor > required.minor) { return true; } else if (minor == required.minor) { return patch >= required.patch; } } return false; } private LTSminVersion(int major, int minor, int patch); static LTSminVersion of(int major, int minor, int patch); static LTSminVersion parse(String version); boolean supports(LTSminVersion required); @Override String toString(); @Override boolean equals(@Nullable Object o); @Override int hashCode(); } | @Test public void testSupports() { Assert.assertTrue(LTSminVersion.of(3, 0, 0).supports(LTSminVersion.of(3, 0, 0))); Assert.assertTrue(LTSminVersion.of(4, 0, 0).supports(LTSminVersion.of(3, 0, 0))); Assert.assertFalse(LTSminVersion.of(2, 0, 0).supports(LTSminVersion.of(3, 0, 0))); Assert.assertTrue(LTSminVersion.of(3, 1, 0).supports(LTSminVersion.of(3, 1, 0))); Assert.assertTrue(LTSminVersion.of(3, 2, 0).supports(LTSminVersion.of(3, 1, 0))); Assert.assertFalse(LTSminVersion.of(3, 1, 0).supports(LTSminVersion.of(3, 2, 0))); Assert.assertTrue(LTSminVersion.of(3, 1, 0).supports(LTSminVersion.of(3, 1, 0))); Assert.assertTrue(LTSminVersion.of(3, 1, 1).supports(LTSminVersion.of(3, 1, 0))); Assert.assertFalse(LTSminVersion.of(3, 1, 0).supports(LTSminVersion.of(3, 1, 1))); } |
Word extends AbstractPrintable implements ArrayWritable<I>, Iterable<I>, Serializable { public <T> Word<T> transform(Function<? super I, ? extends T> transformer) { int len = length(); @Nullable Object[] array = new Object[len]; int i = 0; for (I symbol : this) { array[i++] = transformer.apply(symbol); } return new SharedWord<>(array); } static Comparator<Word<? extends I>> canonicalComparator(Comparator<? super I> symComparator); @SafeVarargs static Word<I> fromSymbols(I... symbols); @SuppressWarnings("unchecked") static Word<I> epsilon(); static Word<I> fromLetter(I letter); static Word<I> fromArray(I[] symbols, int offset, int length); static Word<I> fromList(List<? extends I> symbolList); static Word<Character> fromString(String str); static Word<Character> fromCharSequence(CharSequence cs); @SafeVarargs static Word<I> fromWords(Word<? extends I>... words); static Word<I> fromWords(Collection<? extends Word<? extends I>> words); abstract int length(); @SuppressWarnings("unchecked") static Word<I> upcast(Word<? extends I> word); @Override int hashCode(); @Override boolean equals(@Nullable Object other); @Override java.util.Iterator<I> iterator(); @Override Spliterator<I> spliterator(); @Override void print(Appendable a); boolean isEmpty(); Stream<I> stream(); Stream<I> parallelStream(); final Word<I> subWord(int fromIndex); final Word<I> subWord(int fromIndex, int toIndex); @Override void writeToArray(int offset, @Nullable Object[] array, int tgtOffset, int length); abstract I getSymbol(int index); @Override final int size(); List<I> asList(); List<Word<I>> prefixes(boolean longestFirst); List<Word<I>> suffixes(boolean longestFirst); Word<I> canonicalNext(Alphabet<I> sigma); I lastSymbol(); I firstSymbol(); Word<I> append(I symbol); Word<I> prepend(I symbol); @SafeVarargs final Word<I> concat(Word<? extends I>... words); boolean isPrefixOf(Word<?> other); Word<I> longestCommonPrefix(Word<?> other); final Word<I> prefix(int prefixLen); boolean isSuffixOf(Word<?> other); Word<I> longestCommonSuffix(Word<?> other); final Word<I> suffix(int suffixLen); Word<I> flatten(); Word<I> trimmed(); int[] toIntArray(ToIntFunction<? super I> toInt); Word<T> transform(Function<? super I, ? extends T> transformer); static Collector<I, ?, Word<I>> collector(); } | @Test public void transformTest() { final Word<Character> source = Word.fromCharSequence("abc"); final Word<String> target = Word.fromSymbols("aa", "bb", "cc"); final Word<String> transform = source.transform(c -> new String(new char[] {c, c})); Assert.assertEquals(target, transform); } |
Word extends AbstractPrintable implements ArrayWritable<I>, Iterable<I>, Serializable { public final Word<I> subWord(int fromIndex) { if (fromIndex <= 0) { if (fromIndex == 0) { return this; } throw new IndexOutOfBoundsException("Invalid subword range [" + fromIndex + ",)"); } return subWordInternal(fromIndex, length()); } static Comparator<Word<? extends I>> canonicalComparator(Comparator<? super I> symComparator); @SafeVarargs static Word<I> fromSymbols(I... symbols); @SuppressWarnings("unchecked") static Word<I> epsilon(); static Word<I> fromLetter(I letter); static Word<I> fromArray(I[] symbols, int offset, int length); static Word<I> fromList(List<? extends I> symbolList); static Word<Character> fromString(String str); static Word<Character> fromCharSequence(CharSequence cs); @SafeVarargs static Word<I> fromWords(Word<? extends I>... words); static Word<I> fromWords(Collection<? extends Word<? extends I>> words); abstract int length(); @SuppressWarnings("unchecked") static Word<I> upcast(Word<? extends I> word); @Override int hashCode(); @Override boolean equals(@Nullable Object other); @Override java.util.Iterator<I> iterator(); @Override Spliterator<I> spliterator(); @Override void print(Appendable a); boolean isEmpty(); Stream<I> stream(); Stream<I> parallelStream(); final Word<I> subWord(int fromIndex); final Word<I> subWord(int fromIndex, int toIndex); @Override void writeToArray(int offset, @Nullable Object[] array, int tgtOffset, int length); abstract I getSymbol(int index); @Override final int size(); List<I> asList(); List<Word<I>> prefixes(boolean longestFirst); List<Word<I>> suffixes(boolean longestFirst); Word<I> canonicalNext(Alphabet<I> sigma); I lastSymbol(); I firstSymbol(); Word<I> append(I symbol); Word<I> prepend(I symbol); @SafeVarargs final Word<I> concat(Word<? extends I>... words); boolean isPrefixOf(Word<?> other); Word<I> longestCommonPrefix(Word<?> other); final Word<I> prefix(int prefixLen); boolean isSuffixOf(Word<?> other); Word<I> longestCommonSuffix(Word<?> other); final Word<I> suffix(int suffixLen); Word<I> flatten(); Word<I> trimmed(); int[] toIntArray(ToIntFunction<? super I> toInt); Word<T> transform(Function<? super I, ? extends T> transformer); static Collector<I, ?, Word<I>> collector(); } | @Test public void subwordTest() { final Word<Character> b = Word.fromLetter('b'); final Word<Character> c = Word.fromLetter('c'); final Word<Character> bc = Word.fromSymbols('b', 'c'); final Word<Character> abc = Word.fromCharSequence("abc"); Assert.assertEquals(c, abc.subWord(2)); Assert.assertEquals(bc, abc.subWord(1)); Assert.assertEquals(abc, abc.subWord(0)); Assert.assertEquals(b, abc.subWord(1, 2)); } |
SharedWord extends Word<I> { @Override public int length() { return this.length; } SharedWord(@Nullable Object[] storage); @SuppressWarnings("unchecked") SharedWord(@Nullable Object[] storage, int offset, int length); @SuppressWarnings({"unchecked", "nullness"}) SharedWord(List<? extends I> other); @Override int length(); @Override Iterator<I> iterator(); @Override Spliterator<I> spliterator(); @Override Word<I> subWordInternal(int fromIndex, int toIndex); @Override void writeToArray(int offset, @Nullable Object[] array, int tgtOfs, int num); @Override I getSymbol(int index); @Override I lastSymbol(); @Override I firstSymbol(); @Override Word<I> flatten(); @Override Word<I> trimmed(); } | @Test public void testLength() { Assert.assertEquals(LENGTH, testWord.length()); } |
EmptyWord extends Word<Object> { @Override public int length() { return 0; } @Override int length(); @Override Spliterator<Object> spliterator(); @Override Word<Object> subWordInternal(int fromIndex, int toIndex); @Override void writeToArray(int offset, @Nullable Object[] array, int tgtOffset, int length); @Override Object getSymbol(int index); @Override List<Object> asList(); @Override Word<Object> canonicalNext(Alphabet<Object> sigma); @Override Object lastSymbol(); @Override Word<Object> append(Object symbol); @Override Word<Object> prepend(Object symbol); @Override boolean isPrefixOf(Word<?> other); @Override Word<Object> longestCommonPrefix(Word<?> other); @Override boolean isSuffixOf(Word<?> other); @Override Word<Object> longestCommonSuffix(Word<?> other); @Override Word<Object> flatten(); @Override Word<Object> trimmed(); @Override @SuppressWarnings("unchecked") Word<T> transform(Function<? super Object, ? extends T> transformer); static final EmptyWord INSTANCE; } | @Test public void testLength() { Assert.assertEquals(0, testWord.length()); } |
WordBuilder extends AbstractList<I> { public WordBuilder<I> append(I symbol) { ensureAdditionalCapacity(1); array[length++] = symbol; return this; } WordBuilder(); WordBuilder(int initialCapacity); WordBuilder(I initSym, int count); WordBuilder(int capacity, I initSym, int count); WordBuilder(Word<I> init); WordBuilder(int capacity, Word<I> init); WordBuilder<I> append(I symbol); WordBuilder<I> append(List<? extends I> symList); WordBuilder<I> append(Word<? extends I> word); @SafeVarargs final WordBuilder<I> append(Word<? extends I>... words); @SafeVarargs final WordBuilder<I> append(I... symbols); void ensureAdditionalCapacity(int add); void ensureCapacity(int cap); WordBuilder<I> repeatAppend(int num, Word<I> word); WordBuilder<I> repeatAppend(int num, I symbol); WordBuilder<I> truncate(int truncLen); Word<I> toWord(int fromIndex, int toIndex); Word<I> toWord(); @Override boolean add(I e); @Override I get(int index); @SuppressWarnings("unchecked") I getSymbol(int index); @Override I set(int index, I element); WordBuilder<I> setSymbol(int index, I symbol); @Override void clear(); @Override int size(); WordBuilder<I> reverse(); } | @Test public void appendTest() { WordBuilder<Character> wb = new WordBuilder<>(); final Word<Character> aaa = Word.fromCharSequence("aaa"); final Word<Character> abc = Word.fromCharSequence("abc"); final Word<Character> abcabcabc = abc.concat(abc, abc); wb.append('a'); Assert.assertEquals(1, wb.size()); Assert.assertEquals(Word.fromSymbols('a'), wb.toWord()); wb.clear(); wb.append('a', 'b', 'c'); Assert.assertEquals(3, wb.size()); Assert.assertEquals(abc, wb.toWord()); wb.clear(); wb.append(abc); Assert.assertEquals(3, wb.size()); Assert.assertEquals(abc, wb.toWord()); wb.clear(); wb.append(Arrays.asList('a', 'b', 'c')); Assert.assertEquals(3, wb.size()); Assert.assertEquals(abc, wb.toWord()); wb.clear(); wb.append(abc, abc, abc); Assert.assertEquals(9, wb.size()); Assert.assertEquals(abcabcabc, wb.toWord()); wb.clear(); wb.repeatAppend(3, 'a'); Assert.assertEquals(3, wb.size()); Assert.assertEquals(aaa, wb.toWord()); wb.clear(); wb.repeatAppend(3, abc); Assert.assertEquals(9, wb.size()); Assert.assertEquals(abcabcabc, wb.toWord()); final int bigChunkSize = 27; wb.clear(); wb.repeatAppend(bigChunkSize, abc); Assert.assertEquals(bigChunkSize * 3, wb.size()); Word<Character> buffer = Word.epsilon(); for (int i = 0; i < bigChunkSize; i++) { buffer = buffer.concat(abc); } Assert.assertEquals(buffer, wb.toWord()); } |
WordBuilder extends AbstractList<I> { public WordBuilder<I> reverse() { ensureUnlocked(); int lowIdx = 0, highIdx = length - 1; while (lowIdx < highIdx) { Object tmp = array[lowIdx]; array[lowIdx++] = array[highIdx]; array[highIdx--] = tmp; } return this; } WordBuilder(); WordBuilder(int initialCapacity); WordBuilder(I initSym, int count); WordBuilder(int capacity, I initSym, int count); WordBuilder(Word<I> init); WordBuilder(int capacity, Word<I> init); WordBuilder<I> append(I symbol); WordBuilder<I> append(List<? extends I> symList); WordBuilder<I> append(Word<? extends I> word); @SafeVarargs final WordBuilder<I> append(Word<? extends I>... words); @SafeVarargs final WordBuilder<I> append(I... symbols); void ensureAdditionalCapacity(int add); void ensureCapacity(int cap); WordBuilder<I> repeatAppend(int num, Word<I> word); WordBuilder<I> repeatAppend(int num, I symbol); WordBuilder<I> truncate(int truncLen); Word<I> toWord(int fromIndex, int toIndex); Word<I> toWord(); @Override boolean add(I e); @Override I get(int index); @SuppressWarnings("unchecked") I getSymbol(int index); @Override I set(int index, I element); WordBuilder<I> setSymbol(int index, I symbol); @Override void clear(); @Override int size(); WordBuilder<I> reverse(); } | @Test public void reverseTest() { WordBuilder<Character> wb = new WordBuilder<>(); final Word<Character> abc = Word.fromCharSequence("abc"); final Word<Character> cba = Word.fromCharSequence("cba"); wb.append(abc); wb = wb.reverse(); Assert.assertEquals(cba, wb.toWord()); } |
CharacterizingSets { public static <S, I, T> void findCharacterizingSet(UniversalDeterministicAutomaton<S, I, T, ?, ?> automaton, Collection<? extends I> inputs, Collection<? super Word<I>> result) { findIncrementalCharacterizingSet(automaton, inputs, Collections.emptyList(), result); } private CharacterizingSets(); static void findCharacterizingSet(UniversalDeterministicAutomaton<S, I, T, ?, ?> automaton,
Collection<? extends I> inputs,
Collection<? super Word<I>> result); static void findCharacterizingSet(UniversalDeterministicAutomaton<S, I, T, ?, ?> automaton,
Collection<? extends I> inputs,
S state,
Collection<? super Word<I>> result); static Iterator<Word<I>> characterizingSetIterator(UniversalDeterministicAutomaton<S, I, T, ?, ?> automaton,
Collection<? extends I> inputs); static boolean findIncrementalCharacterizingSet(UniversalDeterministicAutomaton<S, I, T, ?, ?> automaton,
Collection<? extends I> inputs,
Collection<? extends Word<I>> oldSuffixes,
Collection<? super Word<I>> newSuffixes); static Iterator<Word<I>> incrementalCharacterizingSetIterator(UniversalDeterministicAutomaton<S, I, T, ?, ?> automaton,
Collection<? extends I> inputs,
Collection<? extends Word<I>> oldSuffixes); } | @Test public void characterizingDFASingleTest() { final Integer state = DFA.getState(AUTOMATON_SIZE / 2); final List<Word<Integer>> characterizingSet = new ArrayList<>(); CharacterizingSets.findCharacterizingSet(DFA, INPUT_ALPHABET, state, characterizingSet); checkCharacterizingSet(DFA, state, characterizingSet); }
@Test public void characterizingMealySingleTest() { final Integer state = MEALY.getState(AUTOMATON_SIZE / 2); final List<Word<Integer>> characterizingSet = new ArrayList<>(); CharacterizingSets.findCharacterizingSet(MEALY, INPUT_ALPHABET, state, characterizingSet); checkCharacterizingSet(MEALY, state, characterizingSet); } |
WordBuilder extends AbstractList<I> { public Word<I> toWord(int fromIndex, int toIndex) { if (fromIndex < 0 || toIndex > length) { throw new IndexOutOfBoundsException(); } int len = toIndex - fromIndex; lock = true; return new SharedWord<>(array, fromIndex, len); } WordBuilder(); WordBuilder(int initialCapacity); WordBuilder(I initSym, int count); WordBuilder(int capacity, I initSym, int count); WordBuilder(Word<I> init); WordBuilder(int capacity, Word<I> init); WordBuilder<I> append(I symbol); WordBuilder<I> append(List<? extends I> symList); WordBuilder<I> append(Word<? extends I> word); @SafeVarargs final WordBuilder<I> append(Word<? extends I>... words); @SafeVarargs final WordBuilder<I> append(I... symbols); void ensureAdditionalCapacity(int add); void ensureCapacity(int cap); WordBuilder<I> repeatAppend(int num, Word<I> word); WordBuilder<I> repeatAppend(int num, I symbol); WordBuilder<I> truncate(int truncLen); Word<I> toWord(int fromIndex, int toIndex); Word<I> toWord(); @Override boolean add(I e); @Override I get(int index); @SuppressWarnings("unchecked") I getSymbol(int index); @Override I set(int index, I element); WordBuilder<I> setSymbol(int index, I symbol); @Override void clear(); @Override int size(); WordBuilder<I> reverse(); } | @Test public void toWordTest() { WordBuilder<Character> wb = new WordBuilder<>(); final Word<Character> abc = Word.fromCharSequence("abc"); wb.clear(); wb.repeatAppend(3, abc); Assert.assertEquals(abc, wb.toWord(3, 6)); Assert.assertThrows(IndexOutOfBoundsException.class, () -> wb.toWord(-1, wb.size())); Assert.assertThrows(IndexOutOfBoundsException.class, () -> wb.toWord(0, wb.size() + 1)); } |
WordBuilder extends AbstractList<I> { public WordBuilder<I> truncate(int truncLen) { if (truncLen >= length) { return this; } ensureUnlocked(); for (int i = truncLen; i < length; i++) { array[i] = null; } length = truncLen; return this; } WordBuilder(); WordBuilder(int initialCapacity); WordBuilder(I initSym, int count); WordBuilder(int capacity, I initSym, int count); WordBuilder(Word<I> init); WordBuilder(int capacity, Word<I> init); WordBuilder<I> append(I symbol); WordBuilder<I> append(List<? extends I> symList); WordBuilder<I> append(Word<? extends I> word); @SafeVarargs final WordBuilder<I> append(Word<? extends I>... words); @SafeVarargs final WordBuilder<I> append(I... symbols); void ensureAdditionalCapacity(int add); void ensureCapacity(int cap); WordBuilder<I> repeatAppend(int num, Word<I> word); WordBuilder<I> repeatAppend(int num, I symbol); WordBuilder<I> truncate(int truncLen); Word<I> toWord(int fromIndex, int toIndex); Word<I> toWord(); @Override boolean add(I e); @Override I get(int index); @SuppressWarnings("unchecked") I getSymbol(int index); @Override I set(int index, I element); WordBuilder<I> setSymbol(int index, I symbol); @Override void clear(); @Override int size(); WordBuilder<I> reverse(); } | @Test public void truncateTest() { WordBuilder<Character> wb = new WordBuilder<>(); final Word<Character> abc = Word.fromCharSequence("abc"); final Word<Character> abcabc = abc.concat(abc); final Word<Character> abcabcabc = abcabc.concat(abc); wb.clear(); wb.repeatAppend(3, abc); wb = wb.truncate(12); Assert.assertEquals(abcabcabc, wb.toWord()); wb.clear(); wb.repeatAppend(3, abc); wb = wb.truncate(6); Assert.assertEquals(abcabc, wb.toWord()); } |
AbstractLasso implements Lasso<I, D> { @Override public Word<I> getWord() { return word; } <S> AbstractLasso(DetOutputAutomaton<S, I, ?, D> automaton, Collection<? extends I> inputs, int unfoldTimes); @Override DetOutputAutomaton<?, I, ?, D> getAutomaton(); @Override int getUnfolds(); @Override Word<I> getWord(); @Override Word<I> getLoop(); @Override Word<I> getPrefix(); @Override D getOutput(); @Override SortedSet<Integer> getLoopBeginIndices(); @Override Integer getInitialState(); @Override @Nullable Integer getSuccessor(Integer state, I input); @Override Collection<Integer> getStates(); @Override Alphabet<I> getInputAlphabet(); @Override @Nullable Integer getTransition(Integer state, I input); static final String NO_LASSO; } | @Test public void testGetWord() { Assert.assertEquals(lasso1.getWord(), Word.fromSymbols("a")); Assert.assertEquals(lasso2.getWord(), Word.fromSymbols("a", "a")); Assert.assertEquals(lasso3.getWord(), Word.fromSymbols("a", "a", "a")); } |
AbstractLasso implements Lasso<I, D> { @Override public Word<I> getLoop() { return loop; } <S> AbstractLasso(DetOutputAutomaton<S, I, ?, D> automaton, Collection<? extends I> inputs, int unfoldTimes); @Override DetOutputAutomaton<?, I, ?, D> getAutomaton(); @Override int getUnfolds(); @Override Word<I> getWord(); @Override Word<I> getLoop(); @Override Word<I> getPrefix(); @Override D getOutput(); @Override SortedSet<Integer> getLoopBeginIndices(); @Override Integer getInitialState(); @Override @Nullable Integer getSuccessor(Integer state, I input); @Override Collection<Integer> getStates(); @Override Alphabet<I> getInputAlphabet(); @Override @Nullable Integer getTransition(Integer state, I input); static final String NO_LASSO; } | @Test public void testGetLoop() { Assert.assertEquals(lasso1.getLoop(), Word.fromSymbols("a")); Assert.assertEquals(lasso2.getLoop(), Word.fromSymbols("a")); Assert.assertEquals(lasso3.getLoop(), Word.fromSymbols("a", "a")); } |
AbstractLasso implements Lasso<I, D> { @Override public Word<I> getPrefix() { return prefix; } <S> AbstractLasso(DetOutputAutomaton<S, I, ?, D> automaton, Collection<? extends I> inputs, int unfoldTimes); @Override DetOutputAutomaton<?, I, ?, D> getAutomaton(); @Override int getUnfolds(); @Override Word<I> getWord(); @Override Word<I> getLoop(); @Override Word<I> getPrefix(); @Override D getOutput(); @Override SortedSet<Integer> getLoopBeginIndices(); @Override Integer getInitialState(); @Override @Nullable Integer getSuccessor(Integer state, I input); @Override Collection<Integer> getStates(); @Override Alphabet<I> getInputAlphabet(); @Override @Nullable Integer getTransition(Integer state, I input); static final String NO_LASSO; } | @Test public void testGetPrefix() { Assert.assertEquals(lasso1.getPrefix(), Word.epsilon()); Assert.assertEquals(lasso2.getPrefix(), Word.fromSymbols("a")); Assert.assertEquals(lasso3.getPrefix(), Word.fromSymbols("a")); } |
AbstractLasso implements Lasso<I, D> { @Override public SortedSet<Integer> getLoopBeginIndices() { return loopBeginIndices; } <S> AbstractLasso(DetOutputAutomaton<S, I, ?, D> automaton, Collection<? extends I> inputs, int unfoldTimes); @Override DetOutputAutomaton<?, I, ?, D> getAutomaton(); @Override int getUnfolds(); @Override Word<I> getWord(); @Override Word<I> getLoop(); @Override Word<I> getPrefix(); @Override D getOutput(); @Override SortedSet<Integer> getLoopBeginIndices(); @Override Integer getInitialState(); @Override @Nullable Integer getSuccessor(Integer state, I input); @Override Collection<Integer> getStates(); @Override Alphabet<I> getInputAlphabet(); @Override @Nullable Integer getTransition(Integer state, I input); static final String NO_LASSO; } | @Test public void testGetLoopBeginIndices() { final SortedSet<Integer> indices = new TreeSet<>(); indices.add(0); indices.add(1); Assert.assertEquals(lasso1.getLoopBeginIndices(), indices); indices.clear(); indices.add(1); indices.add(2); Assert.assertEquals(lasso2.getLoopBeginIndices(), indices); indices.clear(); indices.add(1); indices.add(3); Assert.assertEquals(lasso3.getLoopBeginIndices(), indices); } |
AbstractIncrementalDFABuilder implements IncrementalDFABuilder<I>, InputAlphabetHolder<I>, Serializable { @Override public void insert(Word<? extends I> word) { insert(word, true); } AbstractIncrementalDFABuilder(Alphabet<I> inputAlphabet); @Override Alphabet<I> getInputAlphabet(); @Override boolean hasDefinitiveInformation(Word<? extends I> word); @Override void insert(Word<? extends I> word); } | @Test public void testConfluenceBug() { Word<Character> wB1 = Word.fromString("aaa"); Word<Character> wB2 = Word.fromString("bba"); Word<Character> wB3 = Word.fromString("aabaa"); incDfa.insert(wB1, true); incDfa.insert(wB2, true); incDfa.insert(wB3, true); Assert.assertEquals(incDfa.lookup(Word.fromString("aababaa")), Acceptance.DONT_KNOW); this.incDfa = createIncrementalDFABuilder(TEST_ALPHABET); }
@Test(dependsOnMethods = "testConfluenceBug") public void testLookup() { Assert.assertEquals(Acceptance.DONT_KNOW, incDfa.lookup(W_1)); Assert.assertEquals(incDfa.lookup(W_2), Acceptance.DONT_KNOW); Assert.assertEquals(incDfa.lookup(W_3), Acceptance.DONT_KNOW); incDfa.insert(W_1, true); Assert.assertEquals(incDfa.lookup(W_1), Acceptance.TRUE); Assert.assertEquals(incDfa.lookup(W_2), Acceptance.DONT_KNOW); Assert.assertEquals(incDfa.lookup(W_3), Acceptance.DONT_KNOW); Assert.assertEquals(incDfa.lookup(W_1.prefix(2)), Acceptance.DONT_KNOW); Assert.assertEquals(incDfa.lookup(W_2.prefix(1)), Acceptance.DONT_KNOW); Assert.assertEquals(incDfa.lookup(W_3.prefix(2)), Acceptance.DONT_KNOW); incDfa.insert(W_2, false); Assert.assertEquals(incDfa.lookup(W_1), Acceptance.TRUE); Assert.assertEquals(incDfa.lookup(W_2), Acceptance.FALSE); Assert.assertEquals(incDfa.lookup(W_3), Acceptance.DONT_KNOW); Assert.assertEquals(incDfa.lookup(W_1.prefix(2)), Acceptance.DONT_KNOW); Assert.assertEquals(incDfa.lookup(W_2.prefix(1)), Acceptance.DONT_KNOW); Assert.assertEquals(incDfa.lookup(W_3.prefix(2)), Acceptance.FALSE); incDfa.insert(W_3, true); Assert.assertEquals(incDfa.lookup(W_1), Acceptance.TRUE); Assert.assertEquals(incDfa.lookup(W_2), Acceptance.FALSE); Assert.assertEquals(incDfa.lookup(W_3), Acceptance.TRUE); Assert.assertEquals(incDfa.lookup(W_1.prefix(2)), Acceptance.DONT_KNOW); Assert.assertEquals(incDfa.lookup(W_2.prefix(1)), Acceptance.DONT_KNOW); Assert.assertEquals(incDfa.lookup(W_3.prefix(2)), Acceptance.FALSE); incDfa.insert(W_4, true); Assert.assertEquals(incDfa.lookup(W_1), Acceptance.TRUE); Assert.assertEquals(incDfa.lookup(W_2), Acceptance.FALSE); Assert.assertEquals(incDfa.lookup(W_3), Acceptance.TRUE); Assert.assertEquals(incDfa.lookup(W_4), Acceptance.TRUE); }
@Test(dependsOnMethods = "testLookup") public void testInsertSame() { int oldSize = incDfa.asGraph().size(); incDfa.insert(W_1, true); Assert.assertEquals(incDfa.asGraph().size(), oldSize); }
@Test(expectedExceptions = ConflictException.class, dependsOnMethods = "testLookup") public void testConflict() { incDfa.insert(W_1, false); }
@Test public void testCounterexampleOfLengthOne() { final IncrementalDFABuilder<Character> incDfa = createIncrementalDFABuilder(TEST_ALPHABET); incDfa.insert(Word.fromCharSequence("a"), true); final CompactDFA<Character> dfa = new CompactDFA<>(TEST_ALPHABET); final Integer q0 = dfa.addInitialState(true); final Integer q1 = dfa.addState(false); dfa.addTransition(q0, 'a', q1); final Word<Character> ce = incDfa.findSeparatingWord(dfa, TEST_ALPHABET, false); Assert.assertNotNull(ce); } |
AbstractIncrementalMealyBuilder implements IncrementalMealyBuilder<I, O>, Serializable { @Override public Word<O> lookup(Word<? extends I> inputWord) { WordBuilder<O> wb = new WordBuilder<>(inputWord.size()); lookup(inputWord, wb); return wb.toWord(); } @Override boolean hasDefinitiveInformation(Word<? extends I> word); @Override Word<O> lookup(Word<? extends I> inputWord); } | @Test public void testConfluenceBug() { incMealy.insert(W_B_1, W_B_1_O); incMealy.insert(W_B_2, W_B_2_O); incMealy.insert(W_B_3, W_B_3_O); Assert.assertFalse(incMealy.lookup(Word.fromString("aababaa"), new ArrayList<>())); this.incMealy = createIncrementalMealyBuilder(TEST_ALPHABET); }
@Test(dependsOnMethods = "testConfluenceBug") public void testLookup() { Assert.assertFalse(incMealy.hasDefinitiveInformation(W_1)); Assert.assertFalse(incMealy.hasDefinitiveInformation(W_2)); Assert.assertFalse(incMealy.hasDefinitiveInformation(W_3)); incMealy.insert(W_1, W_1_O); Assert.assertTrue(incMealy.hasDefinitiveInformation(W_1)); Assert.assertTrue(incMealy.hasDefinitiveInformation(W_1.prefix(2))); Assert.assertFalse(incMealy.hasDefinitiveInformation(W_1.append('a'))); WordBuilder<Character> wb = new WordBuilder<>(); Assert.assertTrue(incMealy.lookup(W_1, wb)); Assert.assertEquals(wb.toWord(), W_1_O); wb.clear(); Assert.assertTrue(incMealy.lookup(W_1.prefix(2), wb)); Assert.assertEquals(wb.toWord(), W_1_O.prefix(2)); wb.clear(); Assert.assertFalse(incMealy.hasDefinitiveInformation(W_2)); Assert.assertFalse(incMealy.hasDefinitiveInformation(W_3)); incMealy.insert(W_2, W_2_O); Assert.assertTrue(incMealy.hasDefinitiveInformation(W_1)); Assert.assertTrue(incMealy.hasDefinitiveInformation(W_2)); Assert.assertFalse(incMealy.hasDefinitiveInformation(W_3)); Assert.assertTrue(incMealy.lookup(W_2, wb)); Assert.assertEquals(wb.toWord(), W_2_O); wb.clear(); Assert.assertTrue(incMealy.lookup(W_2.prefix(1), wb)); Assert.assertEquals(wb.toWord(), W_2_O.prefix(1)); wb.clear(); Assert.assertTrue(incMealy.lookup(W_1, wb)); Assert.assertEquals(wb.toWord(), W_1_O); wb.clear(); incMealy.insert(W_3, W_3_O); Assert.assertTrue(incMealy.hasDefinitiveInformation(W_1)); Assert.assertTrue(incMealy.hasDefinitiveInformation(W_2)); Assert.assertTrue(incMealy.hasDefinitiveInformation(W_3)); Assert.assertTrue(incMealy.lookup(W_3, wb)); Assert.assertEquals(wb.toWord(), W_3_O); wb.clear(); Assert.assertTrue(incMealy.lookup(W_3.prefix(2), wb)); Assert.assertEquals(wb.toWord(), W_3_O.prefix(2)); wb.clear(); Assert.assertTrue(incMealy.lookup(W_1, wb)); Assert.assertEquals(wb.toWord(), W_1_O); wb.clear(); Assert.assertTrue(incMealy.lookup(W_2, wb)); Assert.assertEquals(wb.toWord(), W_2_O); wb.clear(); } |
DFAs { public static <I> CompactDFA<I> and(DFA<?, I> dfa1, DFA<?, I> dfa2, Alphabet<I> inputAlphabet) { return and(dfa1, dfa2, inputAlphabet, new CompactDFA<>(inputAlphabet)); } private DFAs(); static CompactDFA<I> combine(DFA<?, I> dfa1,
DFA<?, I> dfa2,
Alphabet<I> inputAlphabet,
AcceptanceCombiner combiner); static A combine(DFA<?, I> dfa1,
DFA<?, I> dfa2,
Collection<? extends I> inputs,
A out,
AcceptanceCombiner combiner); static CompactDFA<I> and(DFA<?, I> dfa1, DFA<?, I> dfa2, Alphabet<I> inputAlphabet); static A and(DFA<?, I> dfa1,
DFA<?, I> dfa2,
Collection<? extends I> inputs,
A out); static CompactDFA<I> or(DFA<?, I> dfa1, DFA<?, I> dfa2, Alphabet<I> inputAlphabet); static A or(DFA<?, I> dfa1,
DFA<?, I> dfa2,
Collection<? extends I> inputs,
A out); static CompactDFA<I> xor(DFA<?, I> dfa1, DFA<?, I> dfa2, Alphabet<I> inputAlphabet); static A xor(DFA<?, I> dfa1,
DFA<?, I> dfa2,
Collection<? extends I> inputs,
A out); static CompactDFA<I> equiv(DFA<?, I> dfa1, DFA<?, I> dfa2, Alphabet<I> inputAlphabet); static A equiv(DFA<?, I> dfa1,
DFA<?, I> dfa2,
Collection<? extends I> inputs,
A out); static CompactDFA<I> impl(DFA<?, I> dfa1, DFA<?, I> dfa2, Alphabet<I> inputAlphabet); static A impl(DFA<?, I> dfa1,
DFA<?, I> dfa2,
Collection<? extends I> inputs,
A out); static CompactDFA<I> complement(DFA<?, I> dfa, Alphabet<I> inputAlphabet); static A complement(DFA<?, I> dfa,
Collection<? extends I> inputs,
A out); static CompactDFA<I> complete(DFA<?, I> dfa, Alphabet<I> inputs); static A complete(DFA<?, I> dfa, Collection<? extends I> inputs, A out); static CompactDFA<I> minimize(DFA<?, I> dfa, Alphabet<I> alphabet); static CompactDFA<I> minimize(A dfa); static boolean isPrefixClosed(DFA<S, I> dfa, Alphabet<I> alphabet); static boolean acceptsEmptyLanguage(DFA<S, ?> dfa); } | @Test public void testAnd() { DFA<?, Integer> expected = forVector(AND_RESULT); DFA<?, Integer> actual = DFAs.and(testDfa1, testDfa2, testAlphabet); Assert.assertTrue(Automata.testEquivalence(actual, expected, testAlphabet)); } |
DFAs { public static <I> CompactDFA<I> or(DFA<?, I> dfa1, DFA<?, I> dfa2, Alphabet<I> inputAlphabet) { return or(dfa1, dfa2, inputAlphabet, new CompactDFA<>(inputAlphabet)); } private DFAs(); static CompactDFA<I> combine(DFA<?, I> dfa1,
DFA<?, I> dfa2,
Alphabet<I> inputAlphabet,
AcceptanceCombiner combiner); static A combine(DFA<?, I> dfa1,
DFA<?, I> dfa2,
Collection<? extends I> inputs,
A out,
AcceptanceCombiner combiner); static CompactDFA<I> and(DFA<?, I> dfa1, DFA<?, I> dfa2, Alphabet<I> inputAlphabet); static A and(DFA<?, I> dfa1,
DFA<?, I> dfa2,
Collection<? extends I> inputs,
A out); static CompactDFA<I> or(DFA<?, I> dfa1, DFA<?, I> dfa2, Alphabet<I> inputAlphabet); static A or(DFA<?, I> dfa1,
DFA<?, I> dfa2,
Collection<? extends I> inputs,
A out); static CompactDFA<I> xor(DFA<?, I> dfa1, DFA<?, I> dfa2, Alphabet<I> inputAlphabet); static A xor(DFA<?, I> dfa1,
DFA<?, I> dfa2,
Collection<? extends I> inputs,
A out); static CompactDFA<I> equiv(DFA<?, I> dfa1, DFA<?, I> dfa2, Alphabet<I> inputAlphabet); static A equiv(DFA<?, I> dfa1,
DFA<?, I> dfa2,
Collection<? extends I> inputs,
A out); static CompactDFA<I> impl(DFA<?, I> dfa1, DFA<?, I> dfa2, Alphabet<I> inputAlphabet); static A impl(DFA<?, I> dfa1,
DFA<?, I> dfa2,
Collection<? extends I> inputs,
A out); static CompactDFA<I> complement(DFA<?, I> dfa, Alphabet<I> inputAlphabet); static A complement(DFA<?, I> dfa,
Collection<? extends I> inputs,
A out); static CompactDFA<I> complete(DFA<?, I> dfa, Alphabet<I> inputs); static A complete(DFA<?, I> dfa, Collection<? extends I> inputs, A out); static CompactDFA<I> minimize(DFA<?, I> dfa, Alphabet<I> alphabet); static CompactDFA<I> minimize(A dfa); static boolean isPrefixClosed(DFA<S, I> dfa, Alphabet<I> alphabet); static boolean acceptsEmptyLanguage(DFA<S, ?> dfa); } | @Test public void testOr() { DFA<?, Integer> expected = forVector(OR_RESULT); DFA<?, Integer> actual = DFAs.or(testDfa1, testDfa2, testAlphabet); Assert.assertTrue(Automata.testEquivalence(actual, expected, testAlphabet)); } |
GsonTypeChecker extends TypeChecker { @Override public boolean isValidType(Class<?> clazz, boolean throwException) { return isValidType(clazz, throwException, null); } @Override boolean isValidType(Class<?> clazz, boolean throwException); @Override String getTypeName(Class<?> clazz); } | @Test(dataProvider = "validTypes") public void testValidType(Class<?> clazz) { assertTrue(typeChecker.isValidType(clazz)); }
@Test(dataProvider = "validTypes") public void testValidTypeWithException(Class<?> clazz) { assertTrue(typeChecker.isValidType(clazz, true)); }
@Test(dataProvider = "invalidTypes") public void testInvalidType(Class<?> clazz) { assertFalse(typeChecker.isValidType(clazz)); }
@Test(dataProvider = "invalidTypes", expectedExceptions = {IllegalArgumentException.class}) public void testInvalidTypeWithException(Class<?> clazz) { assertFalse(typeChecker.isValidType(clazz, true)); } |
GsonTypeChecker extends TypeChecker { @Override public String getTypeName(Class<?> clazz) { if (clazz == void.class || clazz == Void.class) { return void.class.getName(); } if (clazz == boolean.class || Boolean.class == clazz) { return boolean.class.getName(); } if (clazz == double.class || clazz == float.class || Double.class == clazz || Float.class == clazz) { return double.class.getName(); } if (clazz == byte.class || clazz == char.class || clazz == int.class || clazz == short.class || clazz == long.class || clazz == Character.class || Number.class.isAssignableFrom(clazz)) { return int.class.getName(); } if (clazz == String.class) { return "string"; } if (clazz.isArray()) { return "array"; } return "struct"; } @Override boolean isValidType(Class<?> clazz, boolean throwException); @Override String getTypeName(Class<?> clazz); } | @Test(dataProvider = "typeNames") public void testGetTypeName(Class<?> clazz, String name) { assertEquals(typeChecker.getTypeName(clazz), name); } |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.