gofmt pass

jpath/parser_test.go

@@ -12,8 +12,8 @@ func assertQuery(t *testing.T, toml, query string, ref []interface{}) {
 		t.Errorf("Non-nil toml parse error: %v", err)
 		return
 	}
-  results := Compile(query).Execute(tree)
-	assertValue(t, results, ref, "((" + query + ")) -> ")
+	results := Compile(query).Execute(tree)
+	assertValue(t, results, ref, "(("+query+")) -> ")
 }
 
 func assertValue(t *testing.T, result, ref interface{}, location string) {
@@ -23,14 +23,14 @@ func assertValue(t *testing.T, result, ref interface{}, location string) {
 			t.Errorf("{%s} result value not of type %T: %T",
 				location, node, resultNode)
 		} else {
-      if len(node) != len(resultNode) {
-        t.Errorf("{%s} lengths do not match: %v vs %v",
-          location, node, resultNode)
-      } else {
-        for i, v := range node {
-          assertValue(t, resultNode[i], v, fmt.Sprintf("%s[%d]", location, i))
-        }
-      }
+			if len(node) != len(resultNode) {
+				t.Errorf("{%s} lengths do not match: %v vs %v",
+					location, node, resultNode)
+			} else {
+				for i, v := range node {
+					assertValue(t, resultNode[i], v, fmt.Sprintf("%s[%d]", location, i))
+				}
+			}
 		}
 	case map[string]interface{}:
 		if resultNode, ok := result.(*TomlTree); !ok {
@@ -79,186 +79,186 @@ func TestQueryRoot(t *testing.T) {
 }
 
 func TestQueryKey(t *testing.T) {
-  assertQuery(t,
-    "[foo]\na = 42",
-    "$.foo.a",
+	assertQuery(t,
+		"[foo]\na = 42",
+		"$.foo.a",
 		[]interface{}{
-		  int64(42),
-	  })
+			int64(42),
+		})
 }
 
 func TestQueryKeyString(t *testing.T) {
-  assertQuery(t,
-    "[foo]\na = 42",
-    "$.foo['a']",
+	assertQuery(t,
+		"[foo]\na = 42",
+		"$.foo['a']",
 		[]interface{}{
-		  int64(42),
-	  })
+			int64(42),
+		})
 }
 
 func TestQueryIndex(t *testing.T) {
-  assertQuery(t,
-    "[foo]\na = [1,2,3,4,5,6,7,8,9,0]",
-    "$.foo.a[0]",
+	assertQuery(t,
+		"[foo]\na = [1,2,3,4,5,6,7,8,9,0]",
+		"$.foo.a[0]",
 		[]interface{}{
-		  int64(1),
-	  })
+			int64(1),
+		})
 }
 
 func TestQuerySliceRange(t *testing.T) {
-  assertQuery(t,
-    "[foo]\na = [1,2,3,4,5,6,7,8,9,0]",
-    "$.foo.a[0:5]",
+	assertQuery(t,
+		"[foo]\na = [1,2,3,4,5,6,7,8,9,0]",
+		"$.foo.a[0:5]",
 		[]interface{}{
-		  int64(1),
-		  int64(2),
-		  int64(3),
-		  int64(4),
-		  int64(5),
-	  })
+			int64(1),
+			int64(2),
+			int64(3),
+			int64(4),
+			int64(5),
+		})
 }
 
 func TestQuerySliceStep(t *testing.T) {
-  assertQuery(t,
-    "[foo]\na = [1,2,3,4,5,6,7,8,9,0]",
-    "$.foo.a[0:5:2]",
+	assertQuery(t,
+		"[foo]\na = [1,2,3,4,5,6,7,8,9,0]",
+		"$.foo.a[0:5:2]",
 		[]interface{}{
-		  int64(1),
-		  int64(3),
-		  int64(5),
-	  })
+			int64(1),
+			int64(3),
+			int64(5),
+		})
 }
 
 func TestQueryAny(t *testing.T) {
-  assertQuery(t,
-    "[foo.bar]\na=1\nb=2\n[foo.baz]\na=3\nb=4",
-    "$.foo.*",
+	assertQuery(t,
+		"[foo.bar]\na=1\nb=2\n[foo.baz]\na=3\nb=4",
+		"$.foo.*",
 		[]interface{}{
-		  map[string]interface{}{
-		    "a": int64(1),
-		    "b": int64(2),
-      },
-		  map[string]interface{}{
-		    "a": int64(3),
-		    "b": int64(4),
-      },
-	  })
+			map[string]interface{}{
+				"a": int64(1),
+				"b": int64(2),
+			},
+			map[string]interface{}{
+				"a": int64(3),
+				"b": int64(4),
+			},
+		})
 }
 func TestQueryUnionSimple(t *testing.T) {
-  assertQuery(t,
-    "[foo.bar]\na=1\nb=2\n[baz.foo]\na=3\nb=4\n[gorf.foo]\na=5\nb=6",
-    "$.*[bar,foo]",
+	assertQuery(t,
+		"[foo.bar]\na=1\nb=2\n[baz.foo]\na=3\nb=4\n[gorf.foo]\na=5\nb=6",
+		"$.*[bar,foo]",
 		[]interface{}{
-		  map[string]interface{}{
-		    "a": int64(1),
-		    "b": int64(2),
-      },
-		  map[string]interface{}{
-		    "a": int64(3),
-		    "b": int64(4),
-      },
-		  map[string]interface{}{
-		    "a": int64(5),
-		    "b": int64(6),
-      },
-	  })
+			map[string]interface{}{
+				"a": int64(1),
+				"b": int64(2),
+			},
+			map[string]interface{}{
+				"a": int64(3),
+				"b": int64(4),
+			},
+			map[string]interface{}{
+				"a": int64(5),
+				"b": int64(6),
+			},
+		})
 }
 
 func TestQueryRecursionAll(t *testing.T) {
-  assertQuery(t,
-    "[foo.bar]\na=1\nb=2\n[baz.foo]\na=3\nb=4\n[gorf.foo]\na=5\nb=6",
-    "$..*",
+	assertQuery(t,
+		"[foo.bar]\na=1\nb=2\n[baz.foo]\na=3\nb=4\n[gorf.foo]\na=5\nb=6",
+		"$..*",
 		[]interface{}{
-		  map[string]interface{}{
-		    "bar": map[string]interface{}{
-          "a": int64(1),
-          "b": int64(2),
-        },
-      },
-		  map[string]interface{}{
-		    "a": int64(1),
-		    "b": int64(2),
-      },
-		  int64(1),
-		  int64(2),
-		  map[string]interface{}{
-        "foo": map[string]interface{}{
-          "a": int64(3),
-          "b": int64(4),
-        },
-      },
-		  map[string]interface{}{
-		    "a": int64(3),
-		    "b": int64(4),
-      },
-		  int64(3),
-		  int64(4),
-		  map[string]interface{}{
-        "foo": map[string]interface{}{
-          "a": int64(5),
-          "b": int64(6),
-        },
-      },
-		  map[string]interface{}{
-		    "a": int64(5),
-		    "b": int64(6),
-      },
-		  int64(5),
-		  int64(6),
-	  })
+			map[string]interface{}{
+				"bar": map[string]interface{}{
+					"a": int64(1),
+					"b": int64(2),
+				},
+			},
+			map[string]interface{}{
+				"a": int64(1),
+				"b": int64(2),
+			},
+			int64(1),
+			int64(2),
+			map[string]interface{}{
+				"foo": map[string]interface{}{
+					"a": int64(3),
+					"b": int64(4),
+				},
+			},
+			map[string]interface{}{
+				"a": int64(3),
+				"b": int64(4),
+			},
+			int64(3),
+			int64(4),
+			map[string]interface{}{
+				"foo": map[string]interface{}{
+					"a": int64(5),
+					"b": int64(6),
+				},
+			},
+			map[string]interface{}{
+				"a": int64(5),
+				"b": int64(6),
+			},
+			int64(5),
+			int64(6),
+		})
 }
 
 func TestQueryRecursionUnionSimple(t *testing.T) {
-  assertQuery(t,
-    "[foo.bar]\na=1\nb=2\n[baz.foo]\na=3\nb=4\n[gorf.foo]\na=5\nb=6",
-    "$..['foo','bar']",
+	assertQuery(t,
+		"[foo.bar]\na=1\nb=2\n[baz.foo]\na=3\nb=4\n[gorf.foo]\na=5\nb=6",
+		"$..['foo','bar']",
 		[]interface{}{
-		  map[string]interface{}{
-		    "a": int64(1),
-		    "b": int64(2),
-      },
-		  map[string]interface{}{
-		    "a": int64(3),
-		    "b": int64(4),
-      },
-		  map[string]interface{}{
-		    "a": int64(5),
-		    "b": int64(6),
-      },
-	  })
+			map[string]interface{}{
+				"a": int64(1),
+				"b": int64(2),
+			},
+			map[string]interface{}{
+				"a": int64(3),
+				"b": int64(4),
+			},
+			map[string]interface{}{
+				"a": int64(5),
+				"b": int64(6),
+			},
+		})
 }
 
 func TestQueryScriptFnLast(t *testing.T) {
-  assertQuery(t,
-    "[foo]\na = [0,1,2,3,4,5,6,7,8,9]",
-    "$.foo.a[(last)]",
+	assertQuery(t,
+		"[foo]\na = [0,1,2,3,4,5,6,7,8,9]",
+		"$.foo.a[(last)]",
 		[]interface{}{
-		  int64(9),
-	  })
+			int64(9),
+		})
 }
 
 func TestQueryFilterFnOdd(t *testing.T) {
-  assertQuery(t,
-    "[foo]\na = [0,1,2,3,4,5,6,7,8,9]",
-    "$.foo.a[?(odd)]",
+	assertQuery(t,
+		"[foo]\na = [0,1,2,3,4,5,6,7,8,9]",
+		"$.foo.a[?(odd)]",
 		[]interface{}{
-		  int64(1),
-		  int64(3),
-		  int64(5),
-		  int64(7),
-		  int64(9),
-	  })
+			int64(1),
+			int64(3),
+			int64(5),
+			int64(7),
+			int64(9),
+		})
 }
 
 func TestQueryFilterFnEven(t *testing.T) {
-  assertQuery(t,
-    "[foo]\na = [0,1,2,3,4,5,6,7,8,9]",
-    "$.foo.a[?(even)]",
+	assertQuery(t,
+		"[foo]\na = [0,1,2,3,4,5,6,7,8,9]",
+		"$.foo.a[?(even)]",
 		[]interface{}{
-		  int64(0),
-		  int64(2),
-		  int64(4),
-		  int64(6),
-		  int64(8),
-	  })
+			int64(0),
+			int64(2),
+			int64(4),
+			int64(6),
+			int64(8),
+		})
 }