def test_add_sum(self):
source = "a <- [int] | b <- int | c <- sum a | d <- + c b"
d = generate_examples(source, max_bound=99, min_io_len=3)
program = d["program"]
verify_types(d["io_pairs"], sig=([[int], int], int))
test_io(program, (([3, 5, 4, 7, 5], 3), 27))
self.assertEqual(program.bounds, [(1, 4), (1, 49)])
def test_count_index(self):
source = "a <- [int] | b <- int | c <- index b a | d <- count c a"
d = generate_examples(source, min_io_len=3)
program = d["program"]
verify_types(d["io_pairs"], sig=([[int], int], int))
test_io(program, (([3, 5, 4, 7, 5], 1), 2))
self.assertEqual(program.bounds, [(0, 10), (0, 10)])
def test_sort(self):
source = "a <- [int] | b <- sort a"
d = generate_examples(source, min_io_len=3)
program = d["program"]
verify_types(d["io_pairs"], sig=([int], [int]))
test_io(program, (([3, 5, 4, 7, 5], ), [3, 4, 5, 5, 7]))
self.assertEqual(program.bounds, [(0, 10)])
def test_list_tail(self):
source = "a <- [int] | b <- tail a"
d = generate_examples(source)
program = d["program"]
verify_types(d["io_pairs"], sig=([int], [int]))
test_io(program, (([3, 5, 4, 7, 5], ), [5, 4, 7, 5]))
self.assertEqual(program.bounds, [(0, 10)])
def test_map_subtract_n(self):
source = "a <- [int] | b <- int | c <- map(-) b a"
d = generate_examples(source)
program = d["program"]
verify_types(d["io_pairs"], sig=([[int], int], [int]))
test_io(program, ([[7, 8, 22, 33], 5], [2, 3, 17, 28]))
self.assertEqual(program.bounds, [(1, 5), (1, 5)])
def test_last_sorted(self):
source = "a <- [int] | b <- int | c <- sort a | d <- last c"
d = generate_examples(source)
program = d["program"]
verify_types(d["io_pairs"], sig=([[int], int], int))
test_io(program, (([3, 5, 4, 7, 5], 5), 7))
self.assertEqual(program.bounds, [(0, 10), (0, 10)])
def test_map_add_n(self):
source = "a <- [int] | b <- int | c <- map(+) b a"
d = generate_examples(source)
program = d["program"]
verify_types(d["io_pairs"], sig=([[int], int], [int]))
test_io(program, ([[7, 8, 22, 1, 2, 33], 5], [12, 13, 27, 6, 7, 38]))
self.assertEqual(program.bounds, [(1, 5), (1, 5)])
def test_list_count_n(self):
source = "a <- int | b <- [int] | c <- count a b"
d = generate_examples(source, min_variance=3.5)
program = d["program"]
verify_types(d["io_pairs"], sig=([int, [int]], int))
test_io(program, ((3, [3, 5, 4, 7, 5]), 1))
self.assertEqual(program.bounds, [(0, 10), (0, 10)])
def test_subtract_head(self):
source = "a <- [int] | b <- int | c <- head a | d <- - c b"
d = generate_examples(source)
program = d["program"]
verify_types(d["io_pairs"], sig=([[int], int], int))
test_io(program, ([[7, 8, 22, 1, 2, 33], 5], 2))
self.assertEqual(program.bounds, [(1, 5), (1, 5)])
def test_sum(self):
source = "a <- [int] | b <- sum a"
d = generate_examples(source, max_bound=99)
program = d["program"]
verify_types(d["io_pairs"], sig=([[int], int]))
test_io(program, (([3, 5, 4, 7, 5], ), 24))
self.assertEqual(program.bounds, [(1, 9)])
def test_last_eq(self):
source = "a <- [int] | b <- int | c <- last a | d <- == b c"
d = generate_examples(source)
program = d["program"]
verify_types(d["io_pairs"], sig=([[int], int], bool))
i = [[4, 8, 4, 52, 5, 4], 56]
o = False
test_io(program, (i, o))
self.assertEqual(program.bounds, [(0, 10), (0, 10)])
def test_filter_pos(self):
source = "a <- [int] | b <- filter(positive?) a"
d = generate_examples(source)
program = d["program"]
verify_types(d["io_pairs"], sig=([int], [int]))
i = [[9, 0, 1, 3]]
o = [9, 1, 3]
test_io(program, (i, o))
self.assertEqual(program.bounds, [(0, 10)])
def test_filter_odd(self):
source = "a <- [int] | b <- filter(odd?) a"
d = generate_examples(source)
program = d["program"]
verify_types(d["io_pairs"], sig=([int], [int]))
i = [[8, 7, 20, 1, 8]]
o = [7, 1]
test_io(program, (i, o))
self.assertEqual(program.bounds, [(0, 10)])
def test_filter_eq(self):
source = "a <- [int] | b <- int | c <- filter(==) b a"
d = generate_examples(source)
program = d["program"]
verify_types(d["io_pairs"], sig=([[int], int], [int]))
i = [[7, 0, 6, 8, 9, 6, 70, 3, 9], 8]
o = [8]
test_io(program, (i, o))
self.assertEqual(program.bounds, [(0, 10), (0, 10)])
def test_filter_gt(self):
source = "a <- [int] | b <- int | c <- filter(>) b a"
d = generate_examples(source)
program = d["program"]
verify_types(d["io_pairs"], sig=([[int], int], [int]))
i = [[2, 7, 60, 31, 0, 5, 7, 75], 9]
o = [60, 31, 75]
test_io(program, (i, o))
self.assertEqual(program.bounds, [(0, 10), (0, 10)])
def test_pos(self):
source = "a <- [int] | b <- int | c <- positive? b"
d = generate_examples(source)
program = d["program"]
verify_types(d["io_pairs"], sig=([[int], int], bool))
i = [[4, 2], 5]
o = True
test_io(program, (i, o))
self.assertEqual(program.bounds, [(0, 10), (0, 10)])
def test_odd(self):
source = "a <- [int] | b <- int | c <- odd? b"
d = generate_examples(source)
program = d["program"]
verify_types(d["io_pairs"], sig=([[int], int], bool))
i = [[6], 2]
o = False
test_io(program, (i, o))
self.assertEqual(program.bounds, [(0, 10), (0, 10)])
def test_last_gt(self):
source = "a <- [int] | b <- int | c <- last a | d <- > b c"
d = generate_examples(source)
program = d["program"]
verify_types(d["io_pairs"], sig=([[int], int], bool))
i = [[1, 8, 2, 2, 61, 0, 9], 0]
o = False
test_io(program, (i, o))
self.assertEqual(program.bounds, [(0, 10), (0, 10)])
def test_last_lte(self):
source = "a <- [int] | b <- int | c <- last a | d <- <= b c"
d = generate_examples(source)
program = d["program"]
verify_types(d["io_pairs"], sig=([[int], int], bool))
i = [[0, 1, 3, 7, 15, 9, 8, 0], 3]
o = False
test_io(program, (i, o))
self.assertEqual(program.bounds, [(0, 10), (0, 10)])
def test_filter_lte(self):
source = "a <- [int] | b <- int | c <- filter(<=) b a"
d = generate_examples(source)
program = d["program"]
verify_types(d["io_pairs"], sig=([[int], int], [int]))
i = [[6, 0, 51, 9], 6]
o = [6, 0]
test_io(program, (i, o))
self.assertEqual(program.bounds, [(0, 10), (0, 10)])
def test_count_uniques(self):
source = (
"a <- [int] | b <- tail a | c <- unique b | d <- last c | e <- count d b"
)
d = generate_examples(source, min_io_len=3)
program = d["program"]
verify_types(d["io_pairs"], sig=([int], int))
test_io(program, (([3, 5, 4, 7, 5], ), 1))
self.assertEqual(program.bounds, [(0, 10)])
def test_list_count_head_tail_tail_tail(self):
"""
count (head (tail (tail (tail xs)))) xs
"""
source = "a <- [int] | b <- tail a | c <- tail b | d <- tail c | e <- head d | f <- count e a"
d = generate_examples(source, min_io_len=3)
program = d["program"]
verify_types(d["io_pairs"], sig=([int], int))
test_io(program, (([3, 5, 4, 7, 5], ), 1))
self.assertEqual(program.bounds, [(0, 10)])
def test_list_count_last_tail_in_tail(self):
"""
count (last (tail xs)) (tail xs)
"""
source = "a <- [int] | b <- tail a | c <- last b | d <- count c b"
d = generate_examples(source)
program = d["program"]
verify_types(d["io_pairs"], sig=([int], int))
test_io(program, (([3, 5, 4, 7, 5], ), 2))
self.assertEqual(program.bounds, [(0, 10)])
def test_list_count_head_in_tail(self):
"""
count (head xs) (tail xs)
"""
source = "a <- [int] | b <- tail a | c <- head a | d <- count c b"
d = generate_examples(source)
program = d["program"]
verify_types(d["io_pairs"], sig=([int], int))
test_io(program, (([3, 5, 4, 7, 5], ), 0))
test_io(program, (([5, 4, 7, 5], ), 1))
test_io(program, (([7, 4, 7, 8, 21, 1, 7, 2, 7, 5], ), 3))
self.assertEqual(program.bounds, [(0, 10)])
def test_linq_sum_top_index_sorted(self):
max_bound = 512
min_bound = None
language, _ = get_linq_dsl(max_bound=max_bound, min_bound=min_bound)
source = "a <- int | b <- [int] | c <- SORT b | d <- TAKE a c | e <- SUM d"
d = generate_interesting(
language,
source,
num_examples=10,
timeout=10,
min_bound=min_bound,
max_bound=max_bound,
min_variance=3.5,
maxv=10,
max_io_len=10,
)
program = d["program"]
verify_types(d["io_pairs"], sig=([int, [int]], int))
test_io(program, ((2, [3, 5, 4, 7, 5]), 7))
self.assertEqual(program.bounds, [(0, 10), (-50, 51)])
