diff --git a/.gitignore b/.gitignore
index 540a8d2..2da057d 100644
--- a/.gitignore
+++ b/.gitignore
@@ -22,3 +22,5 @@ _testmain.go
 *.exe
 *.test
 *.prof
+
+.vscode/
\ No newline at end of file
diff --git a/arrays.go b/arrays.go
new file mode 100644
index 0000000..ccb7156
--- /dev/null
+++ b/arrays.go
@@ -0,0 +1,94 @@
+package jsonpatch
+
+import (
+	"fmt"
+	"reflect"
+)
+
+type tmpEl struct {
+	val     interface{}
+	isFixed bool
+}
+
+func diffArrays(a, b []interface{}, p string, forceFullPatch bool) ([]JSONPatchOperation, error) {
+	fullReplace := []JSONPatchOperation{NewPatch("replace", p, b)}
+	patch := []JSONPatchOperation{}
+
+	tmp := make([]tmpEl, len(a))
+	for i, ae := range a {
+		newEl := tmpEl{val: ae}
+		for j := i; j < len(b); j++ {
+			if len(b) <= j { //b is out of bounds
+				break
+			}
+			be := b[j]
+			if reflect.DeepEqual(ae, be) {
+				newEl.isFixed = true // this element should remain in place
+			}
+		}
+		tmp[i] = newEl
+	}
+	// Now we have an array of elements in which we know the original, unmoved elements
+
+	fmt.Println("a>>>", a)
+	fmt.Println("TMP>>>", tmp)
+
+	aIndex := 0
+	bIndex := 0
+	addedDelta := 0
+	maxLen := len(a)
+	if len(b) > maxLen {
+		maxLen = len(b)
+	}
+	for aIndex+addedDelta < maxLen {
+		tmpIndex := aIndex + addedDelta
+		newPath := makePath(p, tmpIndex)
+		if aIndex >= len(a) && bIndex >= len(b) {
+			break
+		}
+		if aIndex >= len(a) { // a is out of bounds, all new items in b must be adds
+			patch = append(patch, NewPatch("add", newPath, b[tmpIndex]))
+			addedDelta++
+			continue
+		}
+		if bIndex >= len(b) { // b is out of bounds, all new items in a must be removed
+			patch = append(patch, NewPatch("remove", newPath, nil))
+			addedDelta--
+			aIndex++
+			continue
+		}
+		// can compare elements, so let's compare them
+		te := tmp[aIndex]
+		for j := bIndex; j < maxLen; j++ {
+			be := b[j]
+			fmt.Printf("Comparing i=%d j=%d ae=%v be=%v\n", aIndex, j, te.val, be)
+			if reflect.DeepEqual(te.val, be) {
+				// element is already in b, move on
+				bIndex++
+				aIndex++
+				break
+			} else {
+				if te.isFixed {
+					fmt.Println("add", newPath, be)
+					patch = append(patch, NewPatch("add", newPath, be))
+					addedDelta++
+					bIndex++
+					break
+				} else {
+					fmt.Println("remove", newPath, be)
+					patch = append(patch, NewPatch("remove", newPath, nil))
+					addedDelta--
+					aIndex++
+					break
+				}
+			}
+		}
+	}
+
+	fmt.Println("patch>>>", patch)
+
+	if forceFullPatch {
+		return patch, nil
+	}
+	return getSmallestPatch(fullReplace, patch), nil
+}
diff --git a/jsonpatch.go b/jsonpatch.go
index 2407c2d..d243085 100644
--- a/jsonpatch.go
+++ b/jsonpatch.go
@@ -10,18 +10,18 @@ import (
 
 var errBadJSONDoc = fmt.Errorf("Invalid JSON Document")
 
-type JsonPatchOperation struct {
+type JSONPatchOperation struct {
 	Operation string      `json:"op"`
 	Path      string      `json:"path"`
 	Value     interface{} `json:"value,omitempty"`
 }
 
-func (j *JsonPatchOperation) Json() string {
+func (j *JSONPatchOperation) JSON() string {
 	b, _ := json.Marshal(j)
 	return string(b)
 }
 
-func (j *JsonPatchOperation) MarshalJSON() ([]byte, error) {
+func (j *JSONPatchOperation) MarshalJSON() ([]byte, error) {
 	var b bytes.Buffer
 	b.WriteString("{")
 	b.WriteString(fmt.Sprintf(`"op":"%s"`, j.Operation))
@@ -39,23 +39,23 @@ func (j *JsonPatchOperation) MarshalJSON() ([]byte, error) {
 	return b.Bytes(), nil
 }
 
-type ByPath []JsonPatchOperation
+type ByPath []JSONPatchOperation
 
 func (a ByPath) Len() int           { return len(a) }
 func (a ByPath) Swap(i, j int)      { a[i], a[j] = a[j], a[i] }
 func (a ByPath) Less(i, j int) bool { return a[i].Path < a[j].Path }
 
-func NewPatch(operation, path string, value interface{}) JsonPatchOperation {
-	return JsonPatchOperation{Operation: operation, Path: path, Value: value}
+func NewPatch(operation, path string, value interface{}) JSONPatchOperation {
+	return JSONPatchOperation{Operation: operation, Path: path, Value: value}
 }
 
 // CreatePatch creates a patch as specified in http://jsonpatch.com/
 //
 // 'a' is original, 'b' is the modified document. Both are to be given as json encoded content.
-// The function will return an array of JsonPatchOperations
+// The function will return an array of JSONPatchOperations
 //
 // An error will be returned if any of the two documents are invalid.
-func CreatePatch(a, b []byte) ([]JsonPatchOperation, error) {
+func CreatePatch(a, b []byte) ([]JSONPatchOperation, error) {
 	var aI interface{}
 	var bI interface{}
 
@@ -68,63 +68,7 @@ func CreatePatch(a, b []byte) ([]JsonPatchOperation, error) {
 		return nil, errBadJSONDoc
 	}
 
-	return handleValues(aI, bI, "", []JsonPatchOperation{})
-}
-
-// Returns true if the values matches (must be json types)
-// The types of the values must match, otherwise it will always return false
-// If two map[string]interface{} are given, all elements must match.
-func matchesValue(av, bv interface{}) bool {
-	if reflect.TypeOf(av) != reflect.TypeOf(bv) {
-		return false
-	}
-	switch at := av.(type) {
-	case string:
-		bt := bv.(string)
-		if bt == at {
-			return true
-		}
-	case float64:
-		bt := bv.(float64)
-		if bt == at {
-			return true
-		}
-	case bool:
-		bt := bv.(bool)
-		if bt == at {
-			return true
-		}
-	case map[string]interface{}:
-		bt := bv.(map[string]interface{})
-		for key := range at {
-			if !matchesValue(at[key], bt[key]) {
-				return false
-			}
-		}
-		for key := range bt {
-			if !matchesValue(at[key], bt[key]) {
-				return false
-			}
-		}
-		return true
-	case []interface{}:
-		bt := bv.([]interface{})
-		if len(bt) != len(at) {
-			return false
-		}
-		for key := range at {
-			if !matchesValue(at[key], bt[key]) {
-				return false
-			}
-		}
-		for key := range bt {
-			if !matchesValue(at[key], bt[key]) {
-				return false
-			}
-		}
-		return true
-	}
-	return false
+	return diff(aI, bI, "", []JSONPatchOperation{})
 }
 
 // From http://tools.ietf.org/html/rfc6901#section-4 :
@@ -149,111 +93,100 @@ func makePath(path string, newPart interface{}) string {
 	return path + "/" + key
 }
 
-// diff returns the (recursive) difference between a and b as an array of JsonPatchOperations.
-func diff(a, b map[string]interface{}, path string, patch []JsonPatchOperation) ([]JsonPatchOperation, error) {
-	for key, bv := range b {
-		p := makePath(path, key)
-		av, ok := a[key]
-		// value was added
-		if !ok {
-			patch = append(patch, NewPatch("add", p, bv))
-			continue
-		}
-		// If types have changed, replace completely
-		if reflect.TypeOf(av) != reflect.TypeOf(bv) {
-			patch = append(patch, NewPatch("replace", p, bv))
-			continue
-		}
-		// Types are the same, compare values
-		var err error
-		patch, err = handleValues(av, bv, p, patch)
-		if err != nil {
-			return nil, err
-		}
+func diff(a, b interface{}, p string, patch []JSONPatchOperation) ([]JSONPatchOperation, error) {
+	// If values are not of the same type simply replace
+	if reflect.TypeOf(a) != reflect.TypeOf(b) {
+		patch = append(patch, NewPatch("replace", p, b))
+		return patch, nil
 	}
-	// Now add all deleted values as nil
-	for key := range a {
-		_, found := b[key]
-		if !found {
-			p := makePath(path, key)
 
-			patch = append(patch, NewPatch("remove", p, nil))
-		}
-	}
-	return patch, nil
-}
-
-func handleValues(av, bv interface{}, p string, patch []JsonPatchOperation) ([]JsonPatchOperation, error) {
 	var err error
-	switch at := av.(type) {
+	var patch2 []JSONPatchOperation
+	switch at := a.(type) {
 	case map[string]interface{}:
-		bt := bv.(map[string]interface{})
-		patch, err = diff(at, bt, p, patch)
+		bt := b.(map[string]interface{})
+		patch2, err = diffObjects(at, bt, p)
 		if err != nil {
 			return nil, err
 		}
+		patch = append(patch, patch2...)
 	case string, float64, bool:
-		if !matchesValue(av, bv) {
-			patch = append(patch, NewPatch("replace", p, bv))
+		if !reflect.DeepEqual(a, b) {
+			patch = append(patch, NewPatch("replace", p, b))
 		}
 	case []interface{}:
-		bt, ok := bv.([]interface{})
+		bt, ok := b.([]interface{})
 		if !ok {
 			// array replaced by non-array
-			patch = append(patch, NewPatch("replace", p, bv))
-		} else if len(at) != len(bt) {
-			// arrays are not the same length
-			patch = append(patch, compareArray(at, bt, p)...)
-
+			patch = append(patch, NewPatch("replace", p, b))
 		} else {
-			for i := range bt {
-				patch, err = handleValues(at[i], bt[i], makePath(p, i), patch)
-				if err != nil {
-					return nil, err
-				}
+			// arrays are not the same length
+			patch2, err = diffArrays(at, bt, p, false)
+			if err != nil {
+				return nil, err
 			}
+			patch = append(patch, patch2...)
 		}
 	case nil:
-		switch bv.(type) {
+		switch b.(type) {
 		case nil:
 			// Both nil, fine.
 		default:
-			patch = append(patch, NewPatch("add", p, bv))
+			patch = append(patch, NewPatch("add", p, b))
 		}
 	default:
-		panic(fmt.Sprintf("Unknown type:%T ", av))
+		panic(fmt.Sprintf("Unknown type:%T ", a))
 	}
 	return patch, nil
 }
 
-func compareArray(av, bv []interface{}, p string) []JsonPatchOperation {
-	retval := []JsonPatchOperation{}
-	//	var err error
-	for i, v := range av {
-		found := false
-		for _, v2 := range bv {
-			if reflect.DeepEqual(v, v2) {
-				found = true
-				break
-			}
+// diff returns the (recursive) difference between a and b as an array of JsonPatchOperations.
+func diffObjects(a, b map[string]interface{}, path string) ([]JSONPatchOperation, error) {
+	fullReplace := []JSONPatchOperation{NewPatch("replace", path, b)}
+	patch := []JSONPatchOperation{}
+	for key, bv := range b {
+		p := makePath(path, key)
+		av, ok := a[key]
+		// Key doesn't exist in original document, value was added
+		if !ok {
+			patch = append(patch, NewPatch("add", p, bv))
+			continue
 		}
-		if !found {
-			retval = append(retval, NewPatch("remove", makePath(p, i), nil))
+		// If types have changed, replace completely
+		if reflect.TypeOf(av) != reflect.TypeOf(bv) {
+			patch = append(patch, NewPatch("replace", p, bv))
+			continue
 		}
-	}
-
-	for i, v := range bv {
-		found := false
-		for _, v2 := range av {
-			if reflect.DeepEqual(v, v2) {
-				found = true
-				break
-			}
+		// Types are the same, compare values
+		var err error
+		patch, err = diff(av, bv, p, patch)
+		if err != nil {
+			return nil, err
 		}
-		if !found {
-			retval = append(retval, NewPatch("add", makePath(p, i), v))
+	}
+	// Now add all deleted values as nil
+	for key := range a {
+		_, ok := b[key]
+		if !ok {
+			p := makePath(path, key)
+			patch = append(patch, NewPatch("remove", p, nil))
 		}
 	}
+	return getSmallestPatch(fullReplace, patch), nil
+}
 
-	return retval
+func getSmallestPatch(patches ...[]JSONPatchOperation) []JSONPatchOperation {
+	smallestPatch := patches[0]
+	b, _ := json.Marshal(patches[0])
+	smallestSize := len(b)
+	for i := 1; i < len(patches); i++ {
+		p := patches[i]
+		b, _ := json.Marshal(p)
+		size := len(b)
+		if size < smallestSize {
+			smallestPatch = p
+			smallestSize = size
+		}
+	}
+	return smallestPatch
 }
diff --git a/jsonpatch_array_test.go b/jsonpatch_array_test.go
new file mode 100644
index 0000000..8873456
--- /dev/null
+++ b/jsonpatch_array_test.go
@@ -0,0 +1,107 @@
+package jsonpatch
+
+import (
+	"encoding/json"
+	"sort"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+var (
+	arrayBase = `{
+  "persons": [{"name":"Ed"},{}]
+}`
+
+	arrayUpdated = `{
+  "persons": [{"name":"Ed"},{},{}]
+}`
+)
+
+func TestArrayAddMultipleEmptyObjects(t *testing.T) {
+	patch, e := CreatePatch([]byte(arrayBase), []byte(arrayUpdated))
+	assert.NoError(t, e)
+	t.Log("Patch:", patch)
+	assert.Equal(t, 1, len(patch), "they should be equal")
+	sort.Sort(ByPath(patch))
+
+	change := patch[0]
+	assert.Equal(t, "add", change.Operation, "they should be equal")
+	assert.Equal(t, "/persons/2", change.Path, "they should be equal")
+	assert.Equal(t, map[string]interface{}{}, change.Value, "they should be equal")
+}
+
+func TestArrayRemoveMultipleEmptyObjects(t *testing.T) {
+	patch, e := CreatePatch([]byte(arrayUpdated), []byte(arrayBase))
+	assert.NoError(t, e)
+	t.Log("Patch:", patch)
+	assert.Equal(t, 1, len(patch), "they should be equal")
+	sort.Sort(ByPath(patch))
+
+	change := patch[0]
+	assert.Equal(t, "remove", change.Operation, "they should be equal")
+	assert.Equal(t, "/persons/2", change.Path, "they should be equal")
+	assert.Equal(t, nil, change.Value, "they should be equal")
+}
+
+var (
+	arrayWithSpacesBase = `{
+	"persons": [{"name":"Ed"},{},{},{"name":"Sally"},{}]
+}`
+
+	arrayWithSpacesUpdated = `{
+  "persons": [{"name":"Ed"},{},{"name":"Sally"},{}]
+}`
+)
+
+// TestArrayRemoveSpaceInbetween tests removing one blank item from a group blanks which is in between non blank items which also end with a blank item. This tests that the correct index is removed
+func TestArrayRemoveSpaceInbetween(t *testing.T) {
+	t.Skip("This test fails. TODO change compareArray algorithm to match by index instead of by object equality")
+	patch, e := CreatePatch([]byte(arrayWithSpacesBase), []byte(arrayWithSpacesUpdated))
+	assert.NoError(t, e)
+	t.Log("Patch:", patch)
+	assert.Equal(t, 1, len(patch), "they should be equal")
+	sort.Sort(ByPath(patch))
+
+	change := patch[0]
+	assert.Equal(t, "remove", change.Operation, "they should be equal")
+	assert.Equal(t, "/persons/2", change.Path, "they should be equal")
+	assert.Equal(t, nil, change.Value, "they should be equal")
+}
+
+func TestArrayPatchCreate(t *testing.T) {
+	cases := map[string]struct {
+		a    string
+		b    string
+		diff string
+	}{
+		"add element as last to array": {
+			`[1, 2, 3]`,
+			`[1, 2, 3, 4]`,
+			`[{"op":"add","path":"/3","value":4}]`,
+		},
+		"add element as first to array": {
+			`[1, 2, 3]`,
+			`[0, 1, 2, 3]`,
+			`[{"op":"add","path":"/0","value":0}]`,
+		},
+		"remove last element from array": {
+			`[1, 2, 3, 4]`,
+			`[1, 2, 3]`,
+			`[{"op":"remove","path":"/3"}]`,
+		},
+	}
+
+	for name, tc := range cases {
+		t.Run(name, func(t *testing.T) {
+			t.Logf(`Running test: "%s"`, name)
+			patch, err := CreatePatch([]byte(tc.a), []byte(tc.b))
+			assert.NoError(t, err)
+
+			patchBytes, err := json.Marshal(patch)
+			assert.NoError(t, err)
+
+			assert.Equal(t, tc.diff, string(patchBytes))
+		})
+	}
+}
diff --git a/jsonpatch_base_test.go b/jsonpatch_base_test.go
new file mode 100644
index 0000000..41c05a2
--- /dev/null
+++ b/jsonpatch_base_test.go
@@ -0,0 +1,33 @@
+package jsonpatch
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestNoChange(t *testing.T) {
+	patch, e := CreatePatch([]byte(`{"a":100, "b":200, "c":"hello"}`), []byte(`{"a":100, "b":200, "c":"hello"}`))
+	assert.NoError(t, e)
+	assert.Equal(t, 0, len(patch))
+}
+
+func TestAddingToArray(t *testing.T) {
+	patch, e := CreatePatch([]byte(`{"a":[1, 2, 3]}`), []byte(`{"a":[1, 2, 3, 4]}`))
+	assert.NoError(t, e)
+	assert.Equal(t, 1, len(patch))
+	p := patch[0]
+	assert.Equal(t, "add", p.Operation)
+	assert.Equal(t, "/a/3", p.Path)
+	assert.Equal(t, float64(4), p.Value)
+}
+
+func TestReplaceScalars(t *testing.T) {
+	patch, e := CreatePatch([]byte(`1`), []byte(`"s"`))
+	assert.NoError(t, e)
+	assert.Equal(t, 1, len(patch))
+	p := patch[0]
+	assert.Equal(t, "replace", p.Operation)
+	assert.Equal(t, "", p.Path)
+	assert.Equal(t, "s", p.Value)
+}
diff --git a/jsonpatch_big_test.go b/jsonpatch_big_test.go
new file mode 100644
index 0000000..94b6324
--- /dev/null
+++ b/jsonpatch_big_test.go
@@ -0,0 +1,67 @@
+package jsonpatch
+
+import (
+	"encoding/json"
+	"fmt"
+	"io/ioutil"
+	"testing"
+
+	evanphx "github.com/evanphx/json-patch"
+	"github.com/stretchr/testify/assert"
+)
+
+type JSONTest struct {
+	Comment  string      `json:"comment"`
+	Original interface{} `json:"doc"`
+	Target   interface{} `json:"expected"`
+	Disabled bool        `json:"disabled"`
+	Error    *string     `json:"error"`
+}
+
+// evanphx/json-patch fails when replacing elements on root level, let's wrap everything into an object
+type RootWrap struct {
+	Root interface{} `json:"root"`
+}
+
+func TestBase(t *testing.T) {
+	file, err := ioutil.ReadFile("tests.json")
+	assert.NoError(t, err)
+
+	var jsonTests []JSONTest
+	err = json.Unmarshal([]byte(file), &jsonTests)
+	assert.NoError(t, err)
+
+	for i, tc := range jsonTests {
+		if tc.Disabled || tc.Error != nil || tc.Original == nil || tc.Target == nil {
+			continue
+		}
+		testName := fmt.Sprintf(`Test #%d %s`, i, tc.Comment)
+		tc.Original = RootWrap{tc.Original}
+		tc.Target = RootWrap{tc.Target}
+		t.Run(testName, func(t *testing.T) {
+			b1, err := json.Marshal(tc.Original)
+			assert.NoError(t, err)
+			b2, err := json.Marshal(tc.Target)
+			assert.NoError(t, err)
+
+			patch, err := CreatePatch(b1, b2)
+			assert.NoError(t, err)
+			pb, err := json.Marshal(patch)
+			assert.NoError(t, err)
+			t.Log("original", string(b1))
+			t.Log("target", string(b2))
+			for i, p := range patch {
+				b, _ := json.Marshal(p)
+				t.Log("diff", i, string(b))
+			}
+
+			ep, err := evanphx.DecodePatch(pb)
+			assert.NoError(t, err)
+
+			modified, err := ep.Apply(b1)
+			assert.NoError(t, err)
+
+			assert.Equal(t, b2, modified)
+		})
+	}
+}
diff --git a/jsonpatch_complex_test.go b/jsonpatch_complex_test.go
index 2a98871..004124f 100644
--- a/jsonpatch_complex_test.go
+++ b/jsonpatch_complex_test.go
@@ -1,9 +1,10 @@
 package jsonpatch
 
 import (
-	"github.com/stretchr/testify/assert"
-	"sort"
+	"encoding/json"
 	"testing"
+
+	"github.com/stretchr/testify/assert"
 )
 
 var complexBase = `{"a":100, "b":[{"c1":"hello", "d1":"foo"},{"c2":"hello2", "d2":"foo2"} ], "e":{"f":200, "g":"h", "i":"j"}}`
@@ -71,18 +72,31 @@ func TestComplexOneAddToArray(t *testing.T) {
 
 func TestComplexVsEmpty(t *testing.T) {
 	patch, e := CreatePatch([]byte(complexBase), []byte(empty))
+	t.Log("base", complexBase)
+	t.Log("target", empty)
+	for i, p := range patch {
+		b, _ := json.Marshal(p)
+		t.Log("patch", i, string(b))
+	}
+
 	assert.NoError(t, e)
-	assert.Equal(t, 3, len(patch), "they should be equal")
-	sort.Sort(ByPath(patch))
+	assert.Equal(t, 1, len(patch), "they should be equal")
 	change := patch[0]
-	assert.Equal(t, "remove", change.Operation, "they should be equal")
-	assert.Equal(t, "/a", change.Path, "they should be equal")
+	assert.Equal(t, "replace", change.Operation, "they should be equal")
+	assert.Equal(t, "", change.Path, "they should be equal")
+
+	// assert.NoError(t, e)
+	// assert.Equal(t, 3, len(patch), "they should be equal")
+	// sort.Sort(ByPath(patch))
+	// change := patch[0]
+	// assert.Equal(t, "remove", change.Operation, "they should be equal")
+	// assert.Equal(t, "/a", change.Path, "they should be equal")
 
-	change = patch[1]
-	assert.Equal(t, "remove", change.Operation, "they should be equal")
-	assert.Equal(t, "/b", change.Path, "they should be equal")
+	// change = patch[1]
+	// assert.Equal(t, "remove", change.Operation, "they should be equal")
+	// assert.Equal(t, "/b", change.Path, "they should be equal")
 
-	change = patch[2]
-	assert.Equal(t, "remove", change.Operation, "they should be equal")
-	assert.Equal(t, "/e", change.Path, "they should be equal")
+	// change = patch[2]
+	// assert.Equal(t, "remove", change.Operation, "they should be equal")
+	// assert.Equal(t, "/e", change.Path, "they should be equal")
 }
diff --git a/jsonpatch_geojson_test.go b/jsonpatch_geojson_test.go
index 6a92da0..9e292e9 100644
--- a/jsonpatch_geojson_test.go
+++ b/jsonpatch_geojson_test.go
@@ -1,18 +1,20 @@
 package jsonpatch
 
 import (
-	"github.com/stretchr/testify/assert"
 	"sort"
 	"testing"
+
+	"github.com/stretchr/testify/assert"
 )
 
-var point = `{"type":"Point", "coordinates":[0.0, 1.0]}`
-var lineString = `{"type":"LineString", "coordinates":[[0.0, 1.0], [2.0, 3.0]]}`
+var point = `{"type":"Point", "coordinates":[0.0, 1.0], "weight":"Lorem Ipsum is simply dummy text of the printing and typesetting industry. Lorem Ipsum has been the industry's standard dummy text ever since the 1500s, when an unknown printer took a galley of type and scrambled it to make a type specimen book."}`
+var lineString = `{"type":"LineString", "coordinates":[[0.0, 1.0], [2.0, 3.0]], "weight":"Lorem Ipsum is simply dummy text of the printing and typesetting industry. Lorem Ipsum has been the industry's standard dummy text ever since the 1500s, when an unknown printer took a galley of type and scrambled it to make a type specimen book."}`
 
 func TestPointLineStringReplace(t *testing.T) {
 	patch, e := CreatePatch([]byte(point), []byte(lineString))
 	assert.NoError(t, e)
-	assert.Equal(t, len(patch), 3, "they should be equal")
+	t.Log(patch)
+	assert.Equal(t, 3, len(patch), "they should be equal")
 	sort.Sort(ByPath(patch))
 	change := patch[0]
 	assert.Equal(t, change.Operation, "replace", "they should be equal")
@@ -20,29 +22,22 @@ func TestPointLineStringReplace(t *testing.T) {
 	assert.Equal(t, change.Value, []interface{}{0.0, 1.0}, "they should be equal")
 	change = patch[1]
 	assert.Equal(t, change.Operation, "replace", "they should be equal")
-	assert.Equal(t, change.Path, "/coordinates/1", "they should be equal")
-	assert.Equal(t, change.Value, []interface{}{2.0, 3.0}, "they should be equal")
-	change = patch[2]
-	assert.Equal(t, change.Operation, "replace", "they should be equal")
-	assert.Equal(t, change.Path, "/type", "they should be equal")
-	assert.Equal(t, change.Value, "LineString", "they should be equal")
+	assert.Equal(t, change.Path, "/coordinates", "they should be equal")
+	assert.Equal(t, change.Value, []interface{}{[]interface{}{0.0, 1.0}, []interface{}{2.0, 3.0}}, "they should be equal")
 }
 
 func TestLineStringPointReplace(t *testing.T) {
 	patch, e := CreatePatch([]byte(lineString), []byte(point))
 	assert.NoError(t, e)
+	t.Log(patch)
 	assert.Equal(t, len(patch), 3, "they should be equal")
 	sort.Sort(ByPath(patch))
 	change := patch[0]
 	assert.Equal(t, change.Operation, "replace", "they should be equal")
-	assert.Equal(t, change.Path, "/coordinates/0", "they should be equal")
-	assert.Equal(t, change.Value, 0.0, "they should be equal")
-	change = patch[1]
-	assert.Equal(t, change.Operation, "replace", "they should be equal")
-	assert.Equal(t, change.Path, "/coordinates/1", "they should be equal")
-	assert.Equal(t, change.Value, 1.0, "they should be equal")
-	change = patch[2]
-	assert.Equal(t, change.Operation, "replace", "they should be equal")
 	assert.Equal(t, change.Path, "/type", "they should be equal")
 	assert.Equal(t, change.Value, "Point", "they should be equal")
+	change = patch[1]
+	assert.Equal(t, change.Operation, "replace", "they should be equal")
+	assert.Equal(t, change.Path, "/coordinates", "they should be equal")
+	assert.Equal(t, change.Value, []interface{}{0.0, 1.0}, "they should be equal")
 }
diff --git a/jsonpatch_hypercomplex_test.go b/jsonpatch_hypercomplex_test.go
index f34423b..dbd3661 100644
--- a/jsonpatch_hypercomplex_test.go
+++ b/jsonpatch_hypercomplex_test.go
@@ -1,9 +1,10 @@
 package jsonpatch
 
 import (
-	"github.com/stretchr/testify/assert"
 	"sort"
 	"testing"
+
+	"github.com/stretchr/testify/assert"
 )
 
 var hyperComplexBase = `
@@ -166,6 +167,10 @@ func TestHyperComplexBoolReplace(t *testing.T) {
 	assert.Equal(t, 3, len(patch), "they should be equal")
 	sort.Sort(ByPath(patch))
 
+	for _, v := range patch {
+		t.Log(v.JSON())
+	}
+
 	change := patch[0]
 	assert.Equal(t, "replace", change.Operation, "they should be equal")
 	assert.Equal(t, "/goods/0/batters/batter/2/type", change.Path, "they should be equal")
@@ -175,7 +180,7 @@ func TestHyperComplexBoolReplace(t *testing.T) {
 	assert.Equal(t, "/goods/2/batters/batter/2", change.Path, "they should be equal")
 	assert.Equal(t, map[string]interface{}{"id": "1003", "type": "Vanilla"}, change.Value, "they should be equal")
 	change = patch[2]
-	assert.Equal(t, change.Operation, "remove", "they should be equal")
-	assert.Equal(t, change.Path, "/goods/2/topping/2", "they should be equal")
+	assert.Equal(t, "remove", change.Operation, "they should be equal")
+	assert.Equal(t, "/goods/2/topping/2", change.Path, "they should be equal")
 	assert.Equal(t, nil, change.Value, "they should be equal")
 }
diff --git a/jsonpatch_json_test.go b/jsonpatch_json_test.go
index 4f8617f..be5aefe 100644
--- a/jsonpatch_json_test.go
+++ b/jsonpatch_json_test.go
@@ -1,31 +1,32 @@
 package jsonpatch
 
 import (
-	"github.com/stretchr/testify/assert"
 	"testing"
+
+	"github.com/stretchr/testify/assert"
 )
 
 func TestMarshalNullableValue(t *testing.T) {
-	p1 := JsonPatchOperation{
+	p1 := JSONPatchOperation{
 		Operation: "replace",
 		Path:      "/a1",
 		Value:     nil,
 	}
-	assert.JSONEq(t, `{"op":"replace", "path":"/a1","value":null}`, p1.Json())
+	assert.JSONEq(t, `{"op":"replace", "path":"/a1","value":null}`, p1.JSON())
 
-	p2 := JsonPatchOperation{
+	p2 := JSONPatchOperation{
 		Operation: "replace",
 		Path:      "/a2",
 		Value:     "v2",
 	}
-	assert.JSONEq(t, `{"op":"replace", "path":"/a2", "value":"v2"}`, p2.Json())
+	assert.JSONEq(t, `{"op":"replace", "path":"/a2", "value":"v2"}`, p2.JSON())
 }
 
 func TestMarshalNonNullableValue(t *testing.T) {
-	p1 := JsonPatchOperation{
+	p1 := JSONPatchOperation{
 		Operation: "remove",
 		Path:      "/a1",
 	}
-	assert.JSONEq(t, `{"op":"remove", "path":"/a1"}`, p1.Json())
+	assert.JSONEq(t, `{"op":"remove", "path":"/a1"}`, p1.JSON())
 
 }
diff --git a/jsonpatch_new_array_test.go b/jsonpatch_new_array_test.go
new file mode 100644
index 0000000..cd6cd63
--- /dev/null
+++ b/jsonpatch_new_array_test.go
@@ -0,0 +1,310 @@
+package jsonpatch
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func Test1(t *testing.T) {
+	patch, e := diffArrays(
+		[]interface{}{"a", "b", "c", "d"},
+		[]interface{}{1, "a", "c", "d", 2},
+		"",
+		true,
+	)
+	assert.NoError(t, e)
+	t.Log("Patch:", patch)
+	assert.Equal(t, 3, len(patch))
+
+	change := patch[0]
+	assert.Equal(t, "add", change.Operation)
+	assert.Equal(t, "/0", change.Path)
+	assert.Equal(t, 1, change.Value)
+
+	change = patch[1]
+	assert.Equal(t, "remove", change.Operation)
+	assert.Equal(t, "/2", change.Path)
+	assert.Equal(t, nil, change.Value)
+
+	change = patch[2]
+	assert.Equal(t, "add", change.Operation)
+	assert.Equal(t, "/4", change.Path)
+	assert.Equal(t, 2, change.Value)
+}
+
+func TestRemovingCenterElement(t *testing.T) {
+	patch, e := diffArrays(
+		[]interface{}{"a", "b", "c"},
+		[]interface{}{"a", "c"},
+		"",
+		true,
+	)
+	assert.NoError(t, e)
+	t.Log("Patch:", patch)
+	assert.Equal(t, 1, len(patch))
+
+	change := patch[0]
+	assert.Equal(t, "remove", change.Operation)
+	assert.Equal(t, "/1", change.Path)
+	assert.Equal(t, nil, change.Value)
+}
+
+func TestAddingCenterElement(t *testing.T) {
+	patch, e := diffArrays(
+		[]interface{}{"a", "c"},
+		[]interface{}{"a", "b", "c"},
+		"",
+		true,
+	)
+	assert.NoError(t, e)
+	t.Log("Patch:", patch)
+	assert.Equal(t, 1, len(patch))
+
+	change := patch[0]
+	assert.Equal(t, "add", change.Operation)
+	assert.Equal(t, "/1", change.Path)
+	assert.Equal(t, "b", change.Value)
+}
+
+func TestAddingElementToEnd(t *testing.T) {
+	patch, e := diffArrays(
+		[]interface{}{"a", "b"},
+		[]interface{}{"a", "b", "c"},
+		"",
+		true,
+	)
+	assert.NoError(t, e)
+	t.Log("Patch:", patch)
+	assert.Equal(t, 1, len(patch))
+
+	change := patch[0]
+	assert.Equal(t, "add", change.Operation)
+	assert.Equal(t, "/2", change.Path)
+	assert.Equal(t, "c", change.Value)
+}
+
+func TestAddingElementToStart(t *testing.T) {
+	patch, e := diffArrays(
+		[]interface{}{"a", "b"},
+		[]interface{}{"0", "a", "b"},
+		"",
+		true,
+	)
+	assert.NoError(t, e)
+	t.Log("Patch:", patch)
+	assert.Equal(t, 1, len(patch))
+
+	change := patch[0]
+	assert.Equal(t, "add", change.Operation)
+	assert.Equal(t, "/0", change.Path)
+	assert.Equal(t, "0", change.Value)
+}
+
+func TestRemovingLastElement(t *testing.T) {
+	patch, e := diffArrays(
+		[]interface{}{"a", "b", "c"},
+		[]interface{}{"a", "b"},
+		"",
+		true,
+	)
+	assert.NoError(t, e)
+	t.Log("Patch:", patch)
+	assert.Equal(t, 1, len(patch))
+
+	change := patch[0]
+	assert.Equal(t, "remove", change.Operation)
+	assert.Equal(t, "/2", change.Path)
+	assert.Equal(t, nil, change.Value)
+}
+
+func TestRemovingFirstElement(t *testing.T) {
+	patch, e := diffArrays(
+		[]interface{}{"a", "b", "c"},
+		[]interface{}{"b", "c"},
+		"",
+		true,
+	)
+	assert.NoError(t, e)
+	t.Log("Patch:", patch)
+	assert.Equal(t, 1, len(patch))
+
+	change := patch[0]
+	assert.Equal(t, "remove", change.Operation)
+	assert.Equal(t, "/0", change.Path)
+	assert.Equal(t, nil, change.Value)
+}
+
+func TestAddingElementsAround(t *testing.T) {
+	patch, e := diffArrays(
+		[]interface{}{"a", "b"},
+		[]interface{}{"x", "a", "b", "y"},
+		"",
+		true,
+	)
+	assert.NoError(t, e)
+	t.Log("Patch:", patch)
+	assert.Equal(t, 2, len(patch))
+
+	change := patch[0]
+	assert.Equal(t, "add", change.Operation)
+	assert.Equal(t, "/0", change.Path)
+	assert.Equal(t, "x", change.Value)
+
+	change = patch[1]
+	assert.Equal(t, "add", change.Operation)
+	assert.Equal(t, "/3", change.Path)
+	assert.Equal(t, "y", change.Value)
+}
+
+func TestRemovingElementsAround(t *testing.T) {
+	patch, e := diffArrays(
+		[]interface{}{"x", "a", "b", "y"},
+		[]interface{}{"a", "b"},
+		"",
+		true,
+	)
+	assert.NoError(t, e)
+	t.Log("Patch:", patch)
+	assert.Equal(t, 2, len(patch))
+
+	change := patch[0]
+	assert.Equal(t, "remove", change.Operation)
+	assert.Equal(t, "/0", change.Path)
+	assert.Equal(t, nil, change.Value)
+
+	change = patch[1]
+	assert.Equal(t, "remove", change.Operation)
+	assert.Equal(t, "/2", change.Path)
+	assert.Equal(t, nil, change.Value)
+}
+
+func TestAddingMultipleElementsAround(t *testing.T) {
+	patch, e := diffArrays(
+		[]interface{}{"a"},
+		[]interface{}{"1", "2", "a", "3", "4"},
+		"",
+		true,
+	)
+	assert.NoError(t, e)
+	t.Log("Patch:", patch)
+	assert.Equal(t, 4, len(patch))
+
+	change := patch[0]
+	assert.Equal(t, "add", change.Operation)
+	assert.Equal(t, "/0", change.Path)
+	assert.Equal(t, "1", change.Value)
+
+	change = patch[1]
+	assert.Equal(t, "add", change.Operation)
+	assert.Equal(t, "/1", change.Path)
+	assert.Equal(t, "2", change.Value)
+
+	change = patch[2]
+	assert.Equal(t, "add", change.Operation)
+	assert.Equal(t, "/3", change.Path)
+	assert.Equal(t, "3", change.Value)
+
+	change = patch[3]
+	assert.Equal(t, "add", change.Operation)
+	assert.Equal(t, "/4", change.Path)
+	assert.Equal(t, "4", change.Value)
+}
+
+func TestRemovingMultipleElementsAround(t *testing.T) {
+	patch, e := diffArrays(
+		[]interface{}{"1", "2", "a", "3", "4"},
+		[]interface{}{"a"},
+		"",
+		true,
+	)
+	assert.NoError(t, e)
+	t.Log("Patch:", patch)
+	assert.Equal(t, 4, len(patch))
+
+	change := patch[0]
+	assert.Equal(t, "remove", change.Operation)
+	assert.Equal(t, "/0", change.Path)
+	assert.Equal(t, nil, change.Value)
+
+	change = patch[1]
+	assert.Equal(t, "remove", change.Operation)
+	assert.Equal(t, "/0", change.Path)
+	assert.Equal(t, nil, change.Value)
+
+	change = patch[2]
+	assert.Equal(t, "remove", change.Operation)
+	assert.Equal(t, "/1", change.Path)
+	assert.Equal(t, nil, change.Value)
+
+	change = patch[3]
+	assert.Equal(t, "remove", change.Operation)
+	assert.Equal(t, "/1", change.Path)
+	assert.Equal(t, nil, change.Value)
+}
+
+func TestAddingElementsToEmptyArray(t *testing.T) {
+	patch, e := diffArrays(
+		[]interface{}{},
+		[]interface{}{"a", "b"},
+		"",
+		true,
+	)
+	assert.NoError(t, e)
+	t.Log("Patch:", patch)
+	assert.Equal(t, 2, len(patch))
+
+	change := patch[0]
+	assert.Equal(t, "add", change.Operation)
+	assert.Equal(t, "/0", change.Path)
+	assert.Equal(t, "a", change.Value)
+
+	change = patch[1]
+	assert.Equal(t, "add", change.Operation)
+	assert.Equal(t, "/1", change.Path)
+	assert.Equal(t, "b", change.Value)
+}
+
+func TestRemovingAllElements(t *testing.T) {
+	patch, e := diffArrays(
+		[]interface{}{"a", "b"},
+		[]interface{}{},
+		"",
+		true,
+	)
+	assert.NoError(t, e)
+	t.Log("Patch:", patch)
+	assert.Equal(t, 2, len(patch))
+
+	change := patch[0]
+	assert.Equal(t, "remove", change.Operation)
+	assert.Equal(t, "/0", change.Path)
+	assert.Equal(t, nil, change.Value)
+
+	change = patch[1]
+	assert.Equal(t, "remove", change.Operation)
+	assert.Equal(t, "/0", change.Path)
+	assert.Equal(t, nil, change.Value)
+}
+
+func TestReplace(t *testing.T) {
+	patch, e := diffArrays(
+		[]interface{}{"a"},
+		[]interface{}{"b"},
+		"",
+		true,
+	)
+	assert.NoError(t, e)
+	t.Log("Patch:", patch)
+	assert.Equal(t, 2, len(patch))
+
+	change := patch[0]
+	assert.Equal(t, "remove", change.Operation)
+	assert.Equal(t, "/0", change.Path)
+	assert.Equal(t, nil, change.Value)
+
+	change = patch[1]
+	assert.Equal(t, "add", change.Operation)
+	assert.Equal(t, "/0", change.Path)
+	assert.Equal(t, "b", change.Value)
+}
diff --git a/jsonpatch_optimise_test.go b/jsonpatch_optimise_test.go
new file mode 100644
index 0000000..b19c8ad
--- /dev/null
+++ b/jsonpatch_optimise_test.go
@@ -0,0 +1,42 @@
+package jsonpatch
+
+import (
+	"fmt"
+	"log"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+const lorem = "Lorem Ipsum is simply dummy text of the printing and typesetting industry. Lorem Ipsum has been the industry's standard dummy text ever since the 1500s, when an unknown printer took a galley of type and scrambled it to make a type specimen book. It has survived not only five centuries, but also the leap into electronic typesetting, remaining essentially unchanged. It was popularised in the 1960s with the release of Letraset sheets containing Lorem Ipsum passages, and more recently with desktop publishing software like Aldus PageMaker including versions of Lorem Ipsum."
+
+// Test should replace the entire array instead of doing separate array operations
+func TestReplaceInsteadOfArrayOps(t *testing.T) {
+	patch, e := CreatePatch([]byte(`{"a":[1, 2, 3]}`), []byte(`{"a":[1, 0, 0]}`))
+	assert.NoError(t, e)
+	log.Println(patch)
+	assert.Equal(t, 1, len(patch))
+	p := patch[0]
+	assert.Equal(t, "replace", p.Operation)
+	assert.Equal(t, "/a", p.Path)
+	assert.Equal(t, []interface{}{float64(1), float64(0), float64(0)}, p.Value)
+}
+
+// Test should do individual array operations because one of the constant values is too big for an efficient replace
+func TestReplaceObjectInArray(t *testing.T) {
+	a := fmt.Sprintf(`[1, 2, {"a": "%s", "b": "2"}]`, lorem)
+	b := fmt.Sprintf(`[1, 2, {"a": "%s", "b": "1", "c": "3"}]`, lorem)
+	patch, e := CreatePatch([]byte(a), []byte(b))
+	assert.NoError(t, e)
+	log.Println(patch)
+	assert.Equal(t, 2, len(patch))
+	p1 := patch[0]
+	assert.Equal(t, "replace", p1.Operation)
+	assert.Equal(t, "/2/b", p1.Path)
+	assert.Equal(t, "1", p1.Value)
+
+	p2 := patch[1]
+	assert.Equal(t, "add", p2.Operation)
+	assert.Equal(t, "/2/c", p2.Path)
+	assert.Equal(t, "3", p2.Value)
+}
diff --git a/jsonpatch_array_at_root_test.go b/jsonpatch_root_array_test.go
similarity index 52%
rename from jsonpatch_array_at_root_test.go
rename to jsonpatch_root_array_test.go
index 60f520f..a0001e4 100644
--- a/jsonpatch_array_at_root_test.go
+++ b/jsonpatch_root_array_test.go
@@ -2,58 +2,59 @@ package jsonpatch
 
 import (
 	"encoding/json"
-	"fmt"
-	"github.com/davecgh/go-spew/spew"
-	jsonpatch "github.com/evanphx/json-patch"
-	"github.com/stretchr/testify/assert"
 	"testing"
+
+	"github.com/stretchr/testify/assert"
 )
 
 func TestJSONPatchCreate(t *testing.T) {
 	cases := map[string]struct {
-		a string
-		b string
+		a    string
+		b    string
+		diff string
 	}{
 		"object": {
 			`{"asdf":"qwerty"}`,
 			`{"asdf":"zzz"}`,
+			`[{"op":"replace","path":"/asdf","value":"zzz"}]`,
 		},
 		"object with array": {
 			`{"items":[{"asdf":"qwerty"}]}`,
 			`{"items":[{"asdf":"bla"},{"asdf":"zzz"}]}`,
+			`[{"op":"remove","path":"/items/0"},{"op":"add","path":"/items/0","value":{"asdf":"bla"}},{"op":"add","path":"/items/1","value":{"asdf":"zzz"}}]`,
 		},
 		"array": {
 			`[{"asdf":"qwerty"}]`,
 			`[{"asdf":"bla"},{"asdf":"zzz"}]`,
+			`[{"op":"replace","path":"/0/asdf","value":"bla"},{"op":"add","path":"/1","value":{"asdf":"zzz"}}]`,
 		},
 		"from empty array": {
 			`[]`,
 			`[{"asdf":"bla"},{"asdf":"zzz"}]`,
+			`[{"op":"add","path":"/0","value":{"asdf":"bla"}},{"op":"add","path":"/1","value":{"asdf":"zzz"}}]`,
 		},
 		"to empty array": {
 			`[{"asdf":"bla"},{"asdf":"zzz"}]`,
 			`[]`,
+			`[{"op":"remove","path":"/0"},{"op":"remove","path":"/1"}]`,
+		},
+		"from object to array": {
+			`{"foo":"bar"}`,
+			`[{"foo":"bar"}]`,
+			`[{"op":"replace","path":"","value":[{"foo":"bar"}]}]`,
 		},
 	}
 
 	for name, tc := range cases {
 		t.Run(name, func(t *testing.T) {
+			t.Logf(`Running test: "%s"`, name)
 			patch, err := CreatePatch([]byte(tc.a), []byte(tc.b))
 			assert.NoError(t, err)
 
 			patchBytes, err := json.Marshal(patch)
 			assert.NoError(t, err)
 
-			fmt.Printf("%s\n", string(patchBytes))
-
-			p, err := jsonpatch.DecodePatch(patchBytes)
-			assert.NoError(t, err)
-
-			res, err := p.Apply([]byte(tc.a))
-			assert.NoError(t, err)
-			spew.Dump(res)
-
-			assert.Equal(t, tc.b, string(res))
+			assert.Equal(t, tc.diff, string(patchBytes))
 		})
 	}
-}
\ No newline at end of file
+}
diff --git a/jsonpatch_simple_test.go b/jsonpatch_simple_test.go
index 1a6ec29..463fb9a 100644
--- a/jsonpatch_simple_test.go
+++ b/jsonpatch_simple_test.go
@@ -76,19 +76,19 @@ func TestOneRemove(t *testing.T) {
 func TestVsEmpty(t *testing.T) {
 	patch, e := CreatePatch([]byte(simpleA), []byte(empty))
 	assert.NoError(t, e)
-	assert.Equal(t, len(patch), 3, "they should be equal")
+	assert.Equal(t, 3, len(patch), "they should be equal")
 	sort.Sort(ByPath(patch))
 	change := patch[0]
-	assert.Equal(t, change.Operation, "remove", "they should be equal")
+	assert.Equal(t, change.Operation, "replace", "they should be equal")
 	assert.Equal(t, change.Path, "/a", "they should be equal")
 
-	change = patch[1]
-	assert.Equal(t, change.Operation, "remove", "they should be equal")
-	assert.Equal(t, change.Path, "/b", "they should be equal")
+	// change = patch[1]
+	// assert.Equal(t, change.Operation, "remove", "they should be equal")
+	// assert.Equal(t, change.Path, "/b", "they should be equal")
 
-	change = patch[2]
-	assert.Equal(t, change.Operation, "remove", "they should be equal")
-	assert.Equal(t, change.Path, "/c", "they should be equal")
+	// change = patch[2]
+	// assert.Equal(t, change.Operation, "remove", "they should be equal")
+	// assert.Equal(t, change.Path, "/c", "they should be equal")
 }
 
 func BenchmarkBigArrays(b *testing.B) {
@@ -101,7 +101,7 @@ func BenchmarkBigArrays(b *testing.B) {
 		a2[i+1] = i
 	}
 	for i := 0; i < b.N; i++ {
-		compareArray(a1, a2, "/")
+		diffArrays(a1, a2, "/", false)
 	}
 }
 
@@ -115,6 +115,6 @@ func BenchmarkBigArrays2(b *testing.B) {
 		a2[i] = i
 	}
 	for i := 0; i < b.N; i++ {
-		compareArray(a1, a2, "/")
+		diffArrays(a1, a2, "/", false)
 	}
 }
diff --git a/tests.json b/tests.json
new file mode 100644
index 0000000..d6a66fc
--- /dev/null
+++ b/tests.json
@@ -0,0 +1,479 @@
+[
+    { "comment": "empty list, empty docs",
+      "doc": {},
+      "patch": [],
+      "expected": {} },
+
+    { "comment": "empty patch list",
+      "doc": {"foo": 1},
+      "patch": [],
+      "expected": {"foo": 1} },
+
+    { "comment": "rearrangements OK?",
+      "doc": {"foo": 1, "bar": 2},
+      "patch": [],
+      "expected": {"bar":2, "foo": 1} },
+
+    { "comment": "rearrangements OK?  How about one level down ... array",
+      "doc": [{"foo": 1, "bar": 2}],
+      "patch": [],
+      "expected": [{"bar":2, "foo": 1}] },
+
+    { "comment": "rearrangements OK?  How about one level down...",
+      "doc": {"foo":{"foo": 1, "bar": 2}},
+      "patch": [],
+      "expected": {"foo":{"bar":2, "foo": 1}} },
+
+    { "comment": "add replaces any existing field",
+      "doc": {"foo": null},
+      "patch": [{"op": "add", "path": "/foo", "value":1}],
+      "expected": {"foo": 1} },
+
+    { "comment": "toplevel array",
+      "doc": [],
+      "patch": [{"op": "add", "path": "/0", "value": "foo"}],
+      "expected": ["foo"] },
+
+    { "comment": "toplevel array, no change",
+      "doc": ["foo"],
+      "patch": [],
+      "expected": ["foo"] },
+
+    { "comment": "toplevel object, numeric string",
+      "doc": {},
+      "patch": [{"op": "add", "path": "/foo", "value": "1"}],
+      "expected": {"foo":"1"} },
+
+    { "comment": "toplevel object, integer",
+      "doc": {},
+      "patch": [{"op": "add", "path": "/foo", "value": 1}],
+      "expected": {"foo":1} },
+
+    { "comment": "Toplevel scalar values OK?",
+      "doc": "foo",
+      "patch": [{"op": "replace", "path": "", "value": "bar"}],
+      "expected": "bar",
+      "disabled": true },
+
+    { "comment": "replace object document with array document?",
+      "doc": {},
+      "patch": [{"op": "add", "path": "", "value": []}],
+      "expected": [] },
+
+    { "comment": "replace array document with object document?",
+      "doc": [],
+      "patch": [{"op": "add", "path": "", "value": {}}],
+      "expected": {} },
+
+    { "comment": "append to root array document?",
+      "doc": [],
+      "patch": [{"op": "add", "path": "/-", "value": "hi"}],
+      "expected": ["hi"] },
+
+    { "comment": "Add, / target",
+      "doc": {},
+      "patch": [ {"op": "add", "path": "/", "value":1 } ],
+      "expected": {"":1} },
+
+    { "comment": "Add, /foo/ deep target (trailing slash)",
+      "doc": {"foo": {}},
+      "patch": [ {"op": "add", "path": "/foo/", "value":1 } ],
+      "expected": {"foo":{"": 1}} },
+
+    { "comment": "Add composite value at top level",
+      "doc": {"foo": 1},
+      "patch": [{"op": "add", "path": "/bar", "value": [1, 2]}],
+      "expected": {"foo": 1, "bar": [1, 2]} },
+
+    { "comment": "Add into composite value",
+      "doc": {"foo": 1, "baz": [{"qux": "hello"}]},
+      "patch": [{"op": "add", "path": "/baz/0/foo", "value": "world"}],
+      "expected": {"foo": 1, "baz": [{"qux": "hello", "foo": "world"}]} },
+
+    { "doc": {"bar": [1, 2]},
+      "patch": [{"op": "add", "path": "/bar/8", "value": "5"}],
+      "error": "Out of bounds (upper)" },
+
+    { "doc": {"bar": [1, 2]},
+      "patch": [{"op": "add", "path": "/bar/-1", "value": "5"}],
+      "error": "Out of bounds (lower)" },
+
+    { "doc": {"foo": 1},
+      "patch": [{"op": "add", "path": "/bar", "value": true}],
+      "expected": {"foo": 1, "bar": true} },
+
+    { "doc": {"foo": 1},
+      "patch": [{"op": "add", "path": "/bar", "value": false}],
+      "expected": {"foo": 1, "bar": false} },
+
+    { "doc": {"foo": 1},
+      "patch": [{"op": "add", "path": "/bar", "value": null}],
+      "expected": {"foo": 1, "bar": null} },
+
+    { "comment": "0 can be an array index or object element name",
+      "doc": {"foo": 1},
+      "patch": [{"op": "add", "path": "/0", "value": "bar"}],
+      "expected": {"foo": 1, "0": "bar" } },
+
+    { "doc": ["foo"],
+      "patch": [{"op": "add", "path": "/1", "value": "bar"}],
+      "expected": ["foo", "bar"] },
+
+    { "doc": ["foo", "sil"],
+      "patch": [{"op": "add", "path": "/1", "value": "bar"}],
+      "expected": ["foo", "bar", "sil"] },
+
+    { "doc": ["foo", "sil"],
+      "patch": [{"op": "add", "path": "/0", "value": "bar"}],
+      "expected": ["bar", "foo", "sil"] },
+
+    { "comment": "push item to array via last index + 1",
+      "doc": ["foo", "sil"],
+      "patch": [{"op":"add", "path": "/2", "value": "bar"}],
+      "expected": ["foo", "sil", "bar"] },
+
+    { "comment": "add item to array at index > length should fail",
+      "doc": ["foo", "sil"],
+      "patch": [{"op":"add", "path": "/3", "value": "bar"}],
+      "error": "index is greater than number of items in array" },
+      
+    { "comment": "test against implementation-specific numeric parsing",
+      "doc": {"1e0": "foo"},
+      "patch": [{"op": "test", "path": "/1e0", "value": "foo"}],
+      "expected": {"1e0": "foo"} },
+
+    { "comment": "test with bad number should fail",
+      "doc": ["foo", "bar"],
+      "patch": [{"op": "test", "path": "/1e0", "value": "bar"}],
+      "error": "test op shouldn't get array element 1" },
+
+    { "doc": ["foo", "sil"],
+      "patch": [{"op": "add", "path": "/bar", "value": 42}],
+      "error": "Object operation on array target" },
+
+    { "doc": ["foo", "sil"],
+      "patch": [{"op": "add", "path": "/1", "value": ["bar", "baz"]}],
+      "expected": ["foo", ["bar", "baz"], "sil"],
+      "comment": "value in array add not flattened" },
+
+    { "doc": {"foo": 1, "bar": [1, 2, 3, 4]},
+      "patch": [{"op": "remove", "path": "/bar"}],
+      "expected": {"foo": 1} },
+
+    { "doc": {"foo": 1, "baz": [{"qux": "hello"}]},
+      "patch": [{"op": "remove", "path": "/baz/0/qux"}],
+      "expected": {"foo": 1, "baz": [{}]} },
+
+    { "doc": {"foo": 1, "baz": [{"qux": "hello"}]},
+      "patch": [{"op": "replace", "path": "/foo", "value": [1, 2, 3, 4]}],
+      "expected": {"foo": [1, 2, 3, 4], "baz": [{"qux": "hello"}]} },
+
+    { "doc": {"foo": [1, 2, 3, 4], "baz": [{"qux": "hello"}]},
+      "patch": [{"op": "replace", "path": "/baz/0/qux", "value": "world"}],
+      "expected": {"foo": [1, 2, 3, 4], "baz": [{"qux": "world"}]} },
+
+    { "doc": ["foo"],
+      "patch": [{"op": "replace", "path": "/0", "value": "bar"}],
+      "expected": ["bar"] },
+
+    { "doc": [""],
+      "patch": [{"op": "replace", "path": "/0", "value": 0}],
+      "expected": [0] },
+
+    { "doc": [""],
+      "patch": [{"op": "replace", "path": "/0", "value": true}],
+      "expected": [true] },
+
+    { "doc": [""],
+      "patch": [{"op": "replace", "path": "/0", "value": false}],
+      "expected": [false] },
+
+    { "doc": [""],
+      "patch": [{"op": "replace", "path": "/0", "value": null}],
+      "expected": [null] },
+
+    { "doc": ["foo", "sil"],
+      "patch": [{"op": "replace", "path": "/1", "value": ["bar", "baz"]}],
+      "expected": ["foo", ["bar", "baz"]],
+      "comment": "value in array replace not flattened" },
+
+    { "comment": "replace whole document",
+      "doc": {"foo": "bar"},
+      "patch": [{"op": "replace", "path": "", "value": {"baz": "qux"}}],
+      "expected": {"baz": "qux"} },
+
+    { "comment": "test replace with missing parent key should fail",
+      "doc": {"bar": "baz"},
+      "patch": [{"op": "replace", "path": "/foo/bar", "value": false}],
+      "error": "replace op should fail with missing parent key" },
+
+    { "comment": "spurious patch properties",
+      "doc": {"foo": 1},
+      "patch": [{"op": "test", "path": "/foo", "value": 1, "spurious": 1}],
+      "expected": {"foo": 1} },
+
+    { "doc": {"foo": null},
+      "patch": [{"op": "test", "path": "/foo", "value": null}],
+      "expected": {"foo": null},
+      "comment": "null value should be valid obj property" },
+
+    { "doc": {"foo": null},
+      "patch": [{"op": "replace", "path": "/foo", "value": "truthy"}],
+      "expected": {"foo": "truthy"},
+      "comment": "null value should be valid obj property to be replaced with something truthy" },
+
+    { "doc": {"foo": null},
+      "patch": [{"op": "move", "from": "/foo", "path": "/bar"}],
+      "expected": {"bar": null},
+      "comment": "null value should be valid obj property to be moved" },
+
+    { "doc": {"foo": null},
+      "patch": [{"op": "copy", "from": "/foo", "path": "/bar"}],
+      "expected": {"foo": null, "bar": null},
+      "comment": "null value should be valid obj property to be copied" },
+
+    { "doc": {"foo": null},
+      "patch": [{"op": "remove", "path": "/foo"}],
+      "expected": {},
+      "comment": "null value should be valid obj property to be removed" },
+
+    { "doc": {"foo": "bar"},
+      "patch": [{"op": "replace", "path": "/foo", "value": null}],
+      "expected": {"foo": null},
+      "comment": "null value should still be valid obj property replace other value" },
+
+    { "doc": {"foo": {"foo": 1, "bar": 2}},
+      "patch": [{"op": "test", "path": "/foo", "value": {"bar": 2, "foo": 1}}],
+      "expected": {"foo": {"foo": 1, "bar": 2}},
+      "comment": "test should pass despite rearrangement" },
+
+    { "doc": {"foo": [{"foo": 1, "bar": 2}]},
+      "patch": [{"op": "test", "path": "/foo", "value": [{"bar": 2, "foo": 1}]}],
+      "expected": {"foo": [{"foo": 1, "bar": 2}]},
+      "comment": "test should pass despite (nested) rearrangement" },
+
+    { "doc": {"foo": {"bar": [1, 2, 5, 4]}},
+      "patch": [{"op": "test", "path": "/foo", "value": {"bar": [1, 2, 5, 4]}}],
+      "expected": {"foo": {"bar": [1, 2, 5, 4]}},
+      "comment": "test should pass - no error" },
+
+    { "doc": {"foo": {"bar": [1, 2, 5, 4]}},
+      "patch": [{"op": "test", "path": "/foo", "value": [1, 2]}],
+      "error": "test op should fail" },
+
+    { "comment": "Whole document",
+      "doc": { "foo": 1 },
+      "patch": [{"op": "test", "path": "", "value": {"foo": 1}}],
+      "disabled": true },
+
+    { "comment": "Empty-string element",
+      "doc": { "": 1 },
+      "patch": [{"op": "test", "path": "/", "value": 1}],
+      "expected": { "": 1 } },
+
+    { "doc": {
+            "foo": ["bar", "baz"],
+            "": 0,
+            "a/b": 1,
+            "c%d": 2,
+            "e^f": 3,
+            "g|h": 4,
+            "i\\j": 5,
+            "k\"l": 6,
+            " ": 7,
+            "m~n": 8
+            },
+      "patch": [{"op": "test", "path": "/foo", "value": ["bar", "baz"]},
+                {"op": "test", "path": "/foo/0", "value": "bar"},
+                {"op": "test", "path": "/", "value": 0},
+                {"op": "test", "path": "/a~1b", "value": 1},
+                {"op": "test", "path": "/c%d", "value": 2},
+                {"op": "test", "path": "/e^f", "value": 3},
+                {"op": "test", "path": "/g|h", "value": 4},
+                {"op": "test", "path":  "/i\\j", "value": 5},
+                {"op": "test", "path": "/k\"l", "value": 6},
+                {"op": "test", "path": "/ ", "value": 7},
+                {"op": "test", "path": "/m~0n", "value": 8}],
+      "expected": {
+            "": 0,
+            " ": 7,
+            "a/b": 1,
+            "c%d": 2,
+            "e^f": 3,
+            "foo": [
+                "bar",
+                "baz"
+            ],
+            "g|h": 4,
+            "i\\j": 5,
+            "k\"l": 6,
+            "m~n": 8
+        }
+    },
+    { "comment": "Move to same location has no effect",
+      "doc": {"foo": 1},
+      "patch": [{"op": "move", "from": "/foo", "path": "/foo"}],
+      "expected": {"foo": 1} },
+
+    { "doc": {"foo": 1, "baz": [{"qux": "hello"}]},
+      "patch": [{"op": "move", "from": "/foo", "path": "/bar"}],
+      "expected": {"baz": [{"qux": "hello"}], "bar": 1} },
+
+    { "doc": {"baz": [{"qux": "hello"}], "bar": 1},
+      "patch": [{"op": "move", "from": "/baz/0/qux", "path": "/baz/1"}],
+      "expected": {"baz": [{}, "hello"], "bar": 1} },
+
+    { "doc": {"baz": [{"qux": "hello"}], "bar": 1},
+      "patch": [{"op": "copy", "from": "/baz/0", "path": "/boo"}],
+      "expected": {"baz":[{"qux":"hello"}],"bar":1,"boo":{"qux":"hello"}} },
+
+    { "comment": "replacing the root of the document is possible with add",
+      "doc": {"foo": "bar"},
+      "patch": [{"op": "add", "path": "", "value": {"baz": "qux"}}],
+      "expected": {"baz":"qux"}},
+
+    { "comment": "Adding to \"/-\" adds to the end of the array",
+      "doc": [ 1, 2 ],
+      "patch": [ { "op": "add", "path": "/-", "value": { "foo": [ "bar", "baz" ] } } ],
+      "expected": [ 1, 2, { "foo": [ "bar", "baz" ] } ]},
+
+    { "comment": "Adding to \"/-\" adds to the end of the array, even n levels down",
+      "doc": [ 1, 2, [ 3, [ 4, 5 ] ] ],
+      "patch": [ { "op": "add", "path": "/2/1/-", "value": { "foo": [ "bar", "baz" ] } } ],
+      "expected": [ 1, 2, [ 3, [ 4, 5, { "foo": [ "bar", "baz" ] } ] ] ]},
+
+    { "comment": "test remove with bad number should fail",
+      "doc": {"foo": 1, "baz": [{"qux": "hello"}]},
+      "patch": [{"op": "remove", "path": "/baz/1e0/qux"}],
+      "error": "remove op shouldn't remove from array with bad number" },
+
+    { "comment": "test remove on array",
+      "doc": [1, 2, 3, 4],
+      "patch": [{"op": "remove", "path": "/0"}],
+      "expected": [2, 3, 4] },
+
+    { "comment": "test repeated removes",
+      "doc": [1, 2, 3, 4],
+      "patch": [{ "op": "remove", "path": "/1" },
+                { "op": "remove", "path": "/2" }],
+      "expected": [1, 3] },
+
+    { "comment": "test remove with bad index should fail",
+      "doc": [1, 2, 3, 4],
+      "patch": [{"op": "remove", "path": "/1e0"}],
+      "error": "remove op shouldn't remove from array with bad number" },
+
+    { "comment": "test replace with bad number should fail",
+      "doc": [""],
+      "patch": [{"op": "replace", "path": "/1e0", "value": false}],
+      "error": "replace op shouldn't replace in array with bad number" },
+
+    { "comment": "test copy with bad number should fail",
+      "doc": {"baz": [1,2,3], "bar": 1},
+      "patch": [{"op": "copy", "from": "/baz/1e0", "path": "/boo"}],
+      "error": "copy op shouldn't work with bad number" },
+
+    { "comment": "test move with bad number should fail",
+      "doc": {"foo": 1, "baz": [1,2,3,4]},
+      "patch": [{"op": "move", "from": "/baz/1e0", "path": "/foo"}],
+      "error": "move op shouldn't work with bad number" },
+
+    { "comment": "test add with bad number should fail",
+      "doc": ["foo", "sil"],
+      "patch": [{"op": "add", "path": "/1e0", "value": "bar"}],
+      "error": "add op shouldn't add to array with bad number" },
+
+    { "comment": "missing 'path' parameter",
+      "doc": {},
+      "patch": [ { "op": "add", "value": "bar" } ],
+      "error": "missing 'path' parameter" },
+
+    { "comment": "'path' parameter with null value",
+      "doc": {},
+      "patch": [ { "op": "add", "path": null, "value": "bar" } ],
+      "error": "null is not valid value for 'path'" },
+
+    { "comment": "invalid JSON Pointer token",
+      "doc": {},
+      "patch": [ { "op": "add", "path": "foo", "value": "bar" } ],
+      "error": "JSON Pointer should start with a slash" },
+
+    { "comment": "missing 'value' parameter to add",
+      "doc": [ 1 ],
+      "patch": [ { "op": "add", "path": "/-" } ],
+      "error": "missing 'value' parameter" },
+
+    { "comment": "missing 'value' parameter to replace",
+      "doc": [ 1 ],
+      "patch": [ { "op": "replace", "path": "/0" } ],
+      "error": "missing 'value' parameter" },
+
+    { "comment": "missing 'value' parameter to test",
+      "doc": [ null ],
+      "patch": [ { "op": "test", "path": "/0" } ],
+      "error": "missing 'value' parameter" },
+
+    { "comment": "missing value parameter to test - where undef is falsy",
+      "doc": [ false ],
+      "patch": [ { "op": "test", "path": "/0" } ],
+      "error": "missing 'value' parameter" },
+
+    { "comment": "missing from parameter to copy",
+      "doc": [ 1 ],
+      "patch": [ { "op": "copy", "path": "/-" } ],
+      "error": "missing 'from' parameter" },
+
+    { "comment": "missing from location to copy",
+      "doc": { "foo": 1 },
+      "patch": [ { "op": "copy", "from": "/bar", "path": "/foo" } ],
+      "error": "missing 'from' location" },
+
+    { "comment": "missing from parameter to move",
+      "doc": { "foo": 1 },
+      "patch": [ { "op": "move", "path": "" } ],
+      "error": "missing 'from' parameter" },
+
+    { "comment": "missing from location to move",
+      "doc": { "foo": 1 },
+      "patch": [ { "op": "move", "from": "/bar", "path": "/foo" } ],
+      "error": "missing 'from' location" },
+
+    { "comment": "duplicate ops",
+      "doc": { "foo": "bar" },
+      "patch": [ { "op": "add", "path": "/baz", "value": "qux",
+                   "op": "move", "from":"/foo" } ],
+      "error": "patch has two 'op' members",
+      "disabled": true },
+
+    { "comment": "unrecognized op should fail",
+      "doc": {"foo": 1},
+      "patch": [{"op": "spam", "path": "/foo", "value": 1}],
+      "error": "Unrecognized op 'spam'" },
+
+    { "comment": "test with bad array number that has leading zeros",
+      "doc": ["foo", "bar"],
+      "patch": [{"op": "test", "path": "/00", "value": "foo"}],
+      "error": "test op should reject the array value, it has leading zeros" },
+
+    { "comment": "test with bad array number that has leading zeros",
+      "doc": ["foo", "bar"],
+      "patch": [{"op": "test", "path": "/01", "value": "bar"}],
+      "error": "test op should reject the array value, it has leading zeros" },
+
+    { "comment": "Removing nonexistent field",
+      "doc": {"foo" : "bar"},
+      "patch": [{"op": "remove", "path": "/baz"}],
+      "error": "removing a nonexistent field should fail" },
+
+    { "comment": "Removing nonexistent index",
+      "doc": ["foo", "bar"],
+      "patch": [{"op": "remove", "path": "/2"}],
+      "error": "removing a nonexistent index should fail" },
+
+    { "comment": "Patch with different capitalisation than doc",
+       "doc": {"foo":"bar"},
+       "patch": [{"op": "add", "path": "/FOO", "value": "BAR"}],
+       "expected": {"foo": "bar", "FOO": "BAR"}
+    }
+
+]
\ No newline at end of file