161 lines
3.4 KiB
Go
161 lines
3.4 KiB
Go
package main
|
|
|
|
import (
|
|
"fmt"
|
|
"testing"
|
|
)
|
|
|
|
func TestParse(t *testing.T) {
|
|
cases := []string{
|
|
"[1,2]",
|
|
"[[3,2],1]",
|
|
"[[3,2],[4,5]]",
|
|
"[[3,2],[[7,8],5]]",
|
|
"[[1,2],3]",
|
|
"[9,[8,7]]",
|
|
"[[1,9],[8,5]]",
|
|
"[[[[1,2],[3,4]],[[5,6],[7,8]]],9]",
|
|
"[[[9,[3,8]],[[0,9],6]],[[[3,7],[4,9]],3]]",
|
|
"[[[[1,3],[5,3]],[[1,3],[8,7]]],[[[4,9],[6,9]],[[8,2],[7,3]]]]",
|
|
}
|
|
for _, input := range cases {
|
|
p := Parse(input)
|
|
if input != p.String() {
|
|
t.Log(p.String())
|
|
t.Fail()
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestMustExplode(t *testing.T) {
|
|
cases := map[string]bool{
|
|
"[1,2]": false,
|
|
"[[[[2,4],4],[2,3]],1]": false,
|
|
"[[[[[4,3],4],4],1],3]": true,
|
|
"[2,[1,[4,[3,[4,3]]]]]": true,
|
|
"[[[[0,7],4],[7,[[8,4],9]]],[1,1]]": true,
|
|
}
|
|
for input, output := range cases {
|
|
if MustExplode(0, Parse(input)) != output {
|
|
t.Log(input)
|
|
t.Fail()
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestSplit(t *testing.T) {
|
|
cases := map[*pair]string{
|
|
{left: 1, right: 1}: "[1,1]",
|
|
{left: 10, right: 1}: "[[5,5],1]",
|
|
{left: 11, right: 1}: "[[5,6],1]",
|
|
{left: 12, right: 1}: "[[6,6],1]",
|
|
{left: 12, right: 12}: "[[6,6],12]",
|
|
{left: 2, right: 12}: "[2,[6,6]]",
|
|
{
|
|
leftp: &pair{left: 15, right: 9},
|
|
rightp: &pair{left: 8, right: 1},
|
|
}: "[[[7,8],9],[8,1]]",
|
|
{
|
|
leftp: &pair{left: 1, right: 9},
|
|
rightp: &pair{left: 8, right: 15},
|
|
}: "[[1,9],[8,[7,8]]]",
|
|
}
|
|
for input, expected := range cases {
|
|
Split(input)
|
|
if input.String() != expected {
|
|
t.Log(input.String(), expected)
|
|
t.Fail()
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestMustSplit(t *testing.T) {
|
|
cases := map[*pair]bool{
|
|
{left: 1, right: 1}: false,
|
|
{left: 10, right: 1}: true,
|
|
{left: 11, right: 1}: true,
|
|
{left: 12, right: 1}: true,
|
|
{left: 12, right: 12}: true,
|
|
{left: 2, right: 12}: true,
|
|
{
|
|
leftp: &pair{left: 1, right: 9},
|
|
rightp: &pair{left: 8, right: 5},
|
|
}: false,
|
|
{
|
|
leftp: &pair{left: 1, right: 9},
|
|
rightp: &pair{left: 8, right: 15},
|
|
}: true,
|
|
}
|
|
for input, output := range cases {
|
|
result := MustSplit(input)
|
|
if result != output {
|
|
t.Log(input.String())
|
|
t.Fail()
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestAdd(t *testing.T) {
|
|
cases := map[string][]*pair{
|
|
"[[1,2],[[3,4],5]]": {
|
|
&pair{left: 1, right: 2},
|
|
&pair{leftp: &pair{left: 3, right: 4}, right: 5},
|
|
},
|
|
}
|
|
for answer, pairs := range cases {
|
|
r := Add(pairs[0], pairs[1])
|
|
if r.String() != answer {
|
|
fmt.Printf("%s %s", r, answer)
|
|
t.Fail()
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestReduce(t *testing.T) {
|
|
cases := map[*pair]string{
|
|
{left: 1, right: 1}: "[1,1]",
|
|
{left: 10, right: 1}: "[[5,5],1]",
|
|
{left: 11, right: 1}: "[[5,6],1]",
|
|
{left: 12, right: 1}: "[[6,6],1]",
|
|
{left: 12, right: 13}: "[[6,6],[6,7]]",
|
|
{left: 2, right: 12}: "[2,[6,6]]",
|
|
{
|
|
leftp: &pair{left: 15, right: 9},
|
|
rightp: &pair{left: 8, right: 1},
|
|
}: "[[[7,8],9],[8,1]]",
|
|
{
|
|
leftp: &pair{left: 1, right: 9},
|
|
rightp: &pair{left: 8, right: 15},
|
|
}: "[[1,9],[8,[7,8]]]",
|
|
}
|
|
for input, expected := range cases {
|
|
Reduce(input)
|
|
if input.String() != expected {
|
|
t.Log(input.String(), expected)
|
|
t.Fail()
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestMagnitude(t *testing.T) {
|
|
cases := map[int]*pair{
|
|
29: {left: 9, right: 1},
|
|
21: {left: 1, right: 9},
|
|
129: {
|
|
leftp: &pair{left: 9, right: 1},
|
|
rightp: &pair{left: 1, right: 9},
|
|
},
|
|
143: {
|
|
leftp: &pair{left: 1, right: 2},
|
|
rightp: &pair{leftp: &pair{left: 3, right: 4}, right: 5},
|
|
},
|
|
}
|
|
for answer, pair := range cases {
|
|
r := pair.Magnitude()
|
|
if r != answer {
|
|
fmt.Printf("%d %d", r, answer)
|
|
t.Fail()
|
|
}
|
|
}
|
|
}
|