001package daikon.test; 002 003import static java.util.logging.Level.INFO; 004import static org.junit.Assert.assertEquals; 005 006import daikon.FileIO; 007import daikon.ProglangType; 008import java.util.Arrays; 009import java.util.Comparator; 010import org.junit.BeforeClass; 011import org.junit.Test; 012import org.plumelib.util.ArraysPlume; 013 014/** Test the ProglangType class. */ 015@SuppressWarnings("nullness") // testing code 016public class ProglangTypeTest { 017 018 /** Creates a ProglangTypeTest. */ 019 public ProglangTypeTest() {} 020 021 /** Comparator for arrays of longs. */ 022 static Comparator<long[]> longarrcomparator = ArraysPlume.LongArrayComparatorLexical.it; 023 024 /** Comparator for arrays of Strings. */ 025 static Comparator<String[]> comparrcomparator = 026 new ArraysPlume.ComparableArrayComparatorLexical<String>(); 027 028 /** prepare for tests */ 029 @BeforeClass 030 public static void setUpClass() { 031 daikon.LogHelper.setupLogs(INFO); 032 FileIO.new_decl_format = true; 033 } 034 035 /** 036 * Asserts that the two arrays are equal. 037 * 038 * @param a the first array; its run-time is long[] 039 * @param b the second array 040 */ 041 void longarrEquals(Object a, long[] b) { 042 assertEquals(0, longarrcomparator.compare((long[]) a, b)); 043 } 044 045 /** 046 * Asserts that the two arrays are equal. 047 * 048 * @param a the first array; its run-time is Comparable[] 049 * @param b the second array; its run-time is Comparable[] 050 */ 051 void comparrEquals(Object a, Object[] b) { 052 String[] a1 = (String[]) a; 053 String[] b1 = (String[]) b; 054 assertEquals( 055 "Arrays differ: " + Arrays.toString(a1) + ", " + Arrays.toString(b), 056 0, 057 comparrcomparator.compare(a1, b1)); 058 } 059 060 // a helper for parse_value 061 private Object parse_value_helper(ProglangType pt, String s) { 062 return pt.parse_value(s, null, "test_parse_value_helper"); 063 } 064 065 // a helper for test_parse_value 066 private void test_parse_value_helper(ProglangType pt, String s, Object value) { 067 Object result = parse_value_helper(pt, s); 068 assertEquals( 069 String.format("test_parse_value_helper(%s, %s, %s) => %s", pt, s, value, result), 070 value, 071 result); 072 } 073 074 @Test 075 public void test_parse_value() { 076 ProglangType pint = ProglangType.INT; 077 test_parse_value_helper(pint, "1", Long.valueOf(1)); 078 test_parse_value_helper(pint, "0", Long.valueOf(0)); 079 test_parse_value_helper(pint, "-3", Long.valueOf(-3)); 080 081 ProglangType pstring = ProglangType.STRING; 082 test_parse_value_helper(pstring, "\"foo\"", "foo"); 083 test_parse_value_helper(pstring, "\"\"", ""); 084 test_parse_value_helper(pstring, "\"\"foo\"\"", "\"foo\""); 085 test_parse_value_helper(pstring, "\"foo bar\"", "foo bar"); 086 test_parse_value_helper(pstring, "null", null); 087 088 ProglangType pinta = ProglangType.INT_ARRAY; 089 longarrEquals(parse_value_helper(pinta, "[]"), new long[] {}); 090 longarrEquals(parse_value_helper(pinta, "[1]"), new long[] {1}); 091 longarrEquals(parse_value_helper(pinta, "[-2]"), new long[] {-2}); 092 longarrEquals(parse_value_helper(pinta, "[1 2 3]"), new long[] {1, 2, 3}); 093 094 ProglangType pstringa = ProglangType.STRING_ARRAY; 095 comparrEquals(parse_value_helper(pstringa, "[]"), new String[] {}); 096 comparrEquals(parse_value_helper(pstringa, "[\"foo\"]"), new String[] {"foo"}); 097 comparrEquals(parse_value_helper(pstringa, "[\"f\\\"oo\"]"), new String[] {"f\"oo"}); 098 comparrEquals(parse_value_helper(pstringa, "[\"f\\noo\"]"), new String[] {"f\noo"}); 099 comparrEquals(parse_value_helper(pstringa, "[\"foo\" \"bar\"]"), new String[] {"foo", "bar"}); 100 comparrEquals( 101 parse_value_helper(pstringa, "[\"foo bar\" \"baz\"]"), new String[] {"foo bar", "baz"}); 102 comparrEquals( 103 parse_value_helper(pstringa, "[\"foo\" null \"baz\"]"), new String[] {"foo", null, "baz"}); 104 } 105}