| // Copyright 2020 The SwiftShader Authors. All Rights Reserved. |
| // |
| // Licensed under the Apache License, Version 2.0 (the "License"); |
| // you may not use this file except in compliance with the License. |
| // You may obtain a copy of the License at |
| // |
| // http://www.apache.org/licenses/LICENSE-2.0 |
| // |
| // Unless required by applicable law or agreed to in writing, software |
| // distributed under the License is distributed on an "AS IS" BASIS, |
| // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| // See the License for the specific language governing permissions and |
| // limitations under the License. |
| |
| package cov_test |
| |
| import ( |
| "reflect" |
| "strings" |
| "testing" |
| |
| cov "." |
| ) |
| |
| var ( |
| fileA = "coverage/file/a" |
| fileB = "coverage/file/b" |
| fileC = "coverage/file/c" |
| fileD = "coverage/file/c" |
| |
| span0 = cov.Span{cov.Location{3, 2}, cov.Location{3, 9}} |
| span1 = cov.Span{cov.Location{4, 1}, cov.Location{5, 1}} |
| span2 = cov.Span{cov.Location{5, 5}, cov.Location{5, 7}} |
| span3 = cov.Span{cov.Location{7, 2}, cov.Location{7, 7}} |
| ) |
| |
| // a |
| // ╭───────┴───────╮ |
| // b c |
| // ╭───┴───╮ ╭───┴───╮ |
| // d e f g |
| // ╭─┴─╮ ╭─┴─╮ ╭─┴─╮ ╭─┴─╮ |
| // h i j k l m n o |
| // ╭┴╮ ╭┴╮ ╭┴╮ ╭┴╮ ╭┴╮ ╭╯ |
| // p q r s t u v w x y z |
| // |
| |
| func TestTree(t *testing.T) { |
| tree := &cov.Tree{} |
| |
| t.Log("Add 'b' with the coverage [0,1]") |
| tree.Add(cov.Path{"a", "b"}, coverage(fileA, span0, span1)) |
| |
| // [0,1] |
| // (a) |
| // ╭─────╯ |
| // b |
| |
| checkSpans(t, tree.Spans(), span0, span1) |
| checkTests(t, tree, `{a:{b}}`) |
| checkCoverage(t, tree, fileA, `a:{[0,1]}`) |
| |
| t.Log("Add 'i' with the coverage [0,1]") |
| tree.Add(cov.Path{"a", "b", "d", "i"}, coverage(fileA, span0, span1)) |
| |
| // [0,1] |
| // (a) |
| // ╭─────╯ |
| // b |
| // ╭──╯ |
| // d |
| // ╰─╮ |
| // i |
| checkSpans(t, tree.Spans(), span0, span1) |
| checkTests(t, tree, `{a:{b:{d:{i}}}}`) |
| checkCoverage(t, tree, fileA, `a:{[0,1]}`) |
| |
| t.Log("Add 'e' with the coverage [0,1,2]") |
| tree.Add(cov.Path{"a", "b", "e"}, coverage(fileA, span0, span1, span2)) |
| |
| // [0,1] |
| // (a) |
| // ┏━━━━━┛ |
| // (b) |
| // ╭──┺━━┓ |
| // d (e)[2] |
| // ╰─╮ |
| // i |
| checkSpans(t, tree.Spans(), span0, span1, span2) |
| checkTests(t, tree, `{a:{b:{d:{i} e}}}`) |
| checkCoverage(t, tree, fileA, `a:{[0,1] b:{e:{[2]}}}`) |
| |
| t.Log("Add 'n' with the coverage [0,3]") |
| tree.Add(cov.Path{"a", "c", "g", "n"}, coverage(fileA, span0, span3)) |
| |
| // [0] |
| // (a) |
| // ┏━━━━━┻━━━━━┓ |
| // [1](b) (c)[3] |
| // ╭──┺━━┓ ╰──╮ |
| // d (e)[2] g |
| // ╰─╮ ╭─╯ |
| // i n |
| checkSpans(t, tree.Spans(), span0, span1, span2, span3) |
| checkTests(t, tree, `{a:{b:{d:{i}e}c:{g:{n}}}}`) |
| checkCoverage(t, tree, fileA, `a:{[0] b:{[1] e:{[2]}} c:{[3]}}`) |
| |
| t.Log("Add 'o' with the coverage [0, 3]") |
| tree.Add(cov.Path{"a", "c", "g", "o"}, coverage(fileA, span0, span3)) |
| |
| // [0] |
| // (a) |
| // ┏━━━━━━━┻━━━━━━━┓ |
| // [1](b) (c)[3] |
| // ╭──┺━━┓ ╰──╮ |
| // d (e)[2] g |
| // ╰─╮ ╭─┴─╮ |
| // i n o |
| checkSpans(t, tree.Spans(), span0, span1, span2, span3) |
| checkTests(t, tree, `{a:{b:{d:{i}e}c:{g:{n o}}}}`) |
| checkCoverage(t, tree, fileA, `a:{[0] b:{[1] e:{[2]}} c:{[3]}}`) |
| |
| t.Log("Add 'f' with the coverage [1]") |
| tree.Add(cov.Path{"a", "c", "f"}, coverage(fileA, span1)) |
| |
| // (a) |
| // ┏━━━━━━━━┻━━━━━━━━┓ |
| // [0,1](b) (c) |
| // ╭──┺━━┓ ┏━━┻━━┓ |
| // d (e)[2] [1](f) (g)[0,3] |
| // ╰─╮ ╭─┴─╮ |
| // i n o |
| checkSpans(t, tree.Spans(), span0, span1, span2, span3) |
| checkTests(t, tree, `{a:{b:{d:{i} e} c:{f g:{n o}}}}`) |
| checkCoverage(t, tree, fileA, `a:{b:{[0,1] e:{[2]}} c:{f:{[1]} g:{[0,3]}}}`) |
| |
| t.Log("Add 'j' with the coverage [3]") |
| tree.Add(cov.Path{"a", "b", "e", "j"}, coverage(fileA, span3)) |
| |
| // (a) |
| // ┏━━━━━━━━┻━━━━━━━━┓ |
| // (b) (c) |
| // ┏━━━┻━━━┓ ┏━━┻━━┓ |
| // [0,1](d) (e)[3] [1](f) (g)[0,3] |
| // ╰─╮ ╭─╯ ╭─┴─╮ |
| // i j n o |
| checkSpans(t, tree.Spans(), span0, span1, span2, span3) |
| checkTests(t, tree, `{a:{b:{d:{i} e:{j}} c:{f g:{n o}}}}`) |
| checkCoverage(t, tree, fileA, `a:{b:{d:{[0,1]} e:{[3]}} c:{f:{[1]} g:{[0,3]}}}`) |
| |
| t.Log("Add 'k' with the coverage [3]") |
| tree.Add(cov.Path{"a", "b", "e", "k"}, coverage(fileA, span3)) |
| |
| // (a) |
| // ┏━━━━━━━━┻━━━━━━━━┓ |
| // (b) (c) |
| // ┏━━━┻━━━┓ ┏━━┻━━┓ |
| // [0,1](d) (e)[3] [1](f) (g)[0,3] |
| // ╰─╮ ╭─┴─╮ ╭─┴─╮ |
| // i j k n o |
| checkSpans(t, tree.Spans(), span0, span1, span2, span3) |
| checkTests(t, tree, `{a:{b:{d:{i} e:{j k}} c:{f g:{n o}}}}`) |
| checkCoverage(t, tree, fileA, `a:{b:{d:{[0,1]} e:{[3]}} c:{f:{[1]} g:{[0,3]}}}`) |
| |
| t.Log("Add 'v' with the coverage [1,2]") |
| tree.Add(cov.Path{"a", "c", "f", "l", "v"}, coverage(fileA, span1, span2)) |
| |
| // (a) |
| // ┏━━━━━━━━┻━━━━━━━━━━┓ |
| // (b) (c) |
| // ┏━━━┻━━━┓ ┏━━┻━━┓ |
| // [0,1](d) (e)[3] [1,2](f) (g)[0,3] |
| // ╰─╮ ╭─┴─╮ ╭─╯ ╭─┴─╮ |
| // i j k l n o |
| // ╭╯ |
| // v |
| checkSpans(t, tree.Spans(), span0, span1, span2, span3) |
| checkTests(t, tree, `{a:{b:{d:{i} e:{j k}} c:{f:{l:{v}} g:{n o}}}}`) |
| checkCoverage(t, tree, fileA, `a:{b:{d:{[0,1]} e:{[3]}} c:{f:{[1,2]} g:{[0,3]}}}`) |
| |
| t.Log("Add 'x' with the coverage [1,2]") |
| tree.Add(cov.Path{"a", "c", "f", "l", "x"}, coverage(fileA, span1, span2)) |
| |
| // (a) |
| // ┏━━━━━━━━┻━━━━━━━━━━┓ |
| // (b) (c) |
| // ┏━━━┻━━━┓ ┏━━┻━━┓ |
| // [0,1](d) (e)[3] [1,2](f) (g)[0,3] |
| // ╰─╮ ╭─┴─╮ ╭─╯ ╭─┴─╮ |
| // i j k l n o |
| // ╭┴╮ |
| // v x |
| checkSpans(t, tree.Spans(), span0, span1, span2, span3) |
| checkTests(t, tree, `{a:{b:{d:{i} e:{j k}} c:{f:{l:{v x}} g:{n o}}}}`) |
| checkCoverage(t, tree, fileA, `a:{b:{d:{[0,1]} e:{[3]}} c:{f:{[1,2]} g:{[0,3]}}}`) |
| |
| t.Log("Add 'z' with the coverage [2]") |
| tree.Add(cov.Path{"a", "c", "g", "n", "z"}, coverage(fileA, span2)) |
| |
| // (a) |
| // ┏━━━━━━━━┻━━━━━━━━━━━━┓ |
| // (b) (c) |
| // ┏━━━┻━━━┓ ┏━━━━┻━━━━┓ |
| // [0,1](d) (e)[3] [1,2](f) (g) |
| // ╰─╮ ╭─┴─╮ ╭─╯ ┏━┻━┓ |
| // i j k l [2](n) (o)[0,3] |
| // ╭┴╮ ╭╯ |
| // v x z |
| checkSpans(t, tree.Spans(), span0, span1, span2, span3) |
| checkTests(t, tree, `{a:{b:{d:{i} e:{j k}} c:{f:{l:{v x}} g:{n: {z} o}}}}`) |
| checkCoverage(t, tree, fileA, `a:{b:{d:{[0,1]} e:{[3]}} c:{f:{[1,2]} g:{n:{[2]} o:{[0,3]}}}}`) |
| |
| tree.Optimize() |
| |
| // (a) |
| // ┏━━━━━━━━┻━━━━━━━━━━━━┓ |
| // (b) (c) |
| // ┏━━━┻━━━┓ ┏━━━━┻━━━━┓ |
| // <0>(d) (e)[3] <2>(f) (g) |
| // ╰─╮ ╭─┴─╮ ╭─╯ ┏━┻━┓ |
| // i j k l [2](n) (o)<1> |
| // ╭┴╮ ╭╯ |
| // v x z |
| checkSpans(t, tree.Spans(), span0, span1, span2, span3) |
| checkGroups(t, tree.FileSpanGroups(fileA), map[cov.SpanGroupID]cov.SpanGroup{ |
| 0: cov.SpanGroup{Spans: spans(0, 1)}, |
| 1: cov.SpanGroup{Spans: spans(0, 3)}, |
| 2: cov.SpanGroup{Spans: spans(1, 2)}, |
| }) |
| checkTests(t, tree, `{a:{b:{d:{i} e:{j k}} c:{f:{l:{v x}} g:{n: {z} o}}}}`) |
| checkCoverage(t, tree, fileA, `a:{b:{d:{<0>} e:{[3]}} c:{f:{<2>} g:{n:{[2]} o:{<1>}}}}`) |
| } |
| |
| func TestTreeOptInvertForCommon(t *testing.T) { |
| tree := &cov.Tree{} |
| |
| tree.Add(cov.Path{"a", "b"}, coverage(fileA, span0)) |
| tree.Add(cov.Path{"a", "c"}, coverage(fileA, span0)) |
| tree.Add(cov.Path{"a", "d"}, coverage(fileA, span0)) |
| tree.Add(cov.Path{"a", "e"}, coverage(fileA, span1)) |
| tree.Add(cov.Path{"a", "f"}, coverage(fileA, span1)) |
| tree.Add(cov.Path{"a", "g"}, coverage(fileA, span0)) |
| tree.Add(cov.Path{"a", "h"}, coverage(fileA, span0)) |
| tree.Add(cov.Path{"a", "i"}, coverage(fileA, span0)) |
| |
| // (a) |
| // ┏━━━┳━━━┳━━━┳━┻━┳━━━┳━━━┳━━━┓ |
| // (b) (c) (d) (e) (f) (g) (h) (i) |
| // [0] [0] [0] [1] [1] [0] [0] [0] |
| checkSpans(t, tree.Spans(), span0, span1) |
| checkTests(t, tree, `{a:{b c d e f g h i}}`) |
| checkCoverage(t, tree, fileA, `a:{b:{[0]} c:{[0]} d:{[0]} e:{[1]} f:{[1]} g:{[0]} h:{[0]} i:{[0]}}`) |
| |
| tree.Optimize() |
| |
| // [0] |
| // (a) |
| // ╭───┬───┬───┲━┻━┱───┬───┬───╮ |
| // b c d ┏┛ ┗┓ g h i |
| // (e) (f) |
| // <0> <0> |
| checkSpans(t, tree.Spans(), span0, span1) |
| checkGroups(t, tree.FileSpanGroups(fileA), map[cov.SpanGroupID]cov.SpanGroup{ |
| 0: cov.SpanGroup{Spans: spans(0, 1)}, |
| }) |
| checkTests(t, tree, `{a:{b c d e f g h i}}`) |
| checkCoverage(t, tree, fileA, `a:{[0] e:{<0>} f:{<0>}}`) |
| } |
| |
| func TestTreeOptDontInvertForCommon(t *testing.T) { |
| tree := &cov.Tree{} |
| |
| tree.Add(cov.Path{"a", "b"}, coverage(fileA, span0)) |
| tree.Add(cov.Path{"a", "c"}, coverage(fileA, span0)) |
| tree.Add(cov.Path{"a", "d"}, coverage(fileA, span0)) |
| tree.Add(cov.Path{"a", "e"}, coverage(fileA, span1)) |
| tree.Add(cov.Path{"a", "f"}, coverage(fileA, span1)) |
| tree.Add(cov.Path{"a", "g"}, coverage(fileA, span2)) |
| tree.Add(cov.Path{"a", "h"}, coverage(fileA, span2)) |
| tree.Add(cov.Path{"a", "i"}, coverage(fileA, span2)) |
| |
| // (a) |
| // ┏━━━┳━━━┳━━━┳━┻━┳━━━┳━━━┳━━━┓ |
| // (b) (c) (d) (e) (f) (g) (h) (i) |
| // [0] [0] [0] [1] [1] [2] [2] [2] |
| checkSpans(t, tree.Spans(), span0, span1, span2) |
| checkTests(t, tree, `{a:{b c d e f g h i}}`) |
| checkCoverage(t, tree, fileA, `a:{b:{[0]} c:{[0]} d:{[0]} e:{[1]} f:{[1]} g:{[2]} h:{[2]} i:{[2]}}`) |
| |
| tree.Optimize() |
| |
| // (a) |
| // ┏━━━┳━━━┳━━━┳━┻━┳━━━┳━━━┳━━━┓ |
| // (b) (c) (d) (e) (f) (g) (h) (i) |
| // [0] [0] [0] [1] [1] [2] [2] [2] |
| checkSpans(t, tree.Spans(), span0, span1, span2) |
| checkTests(t, tree, `{a:{b c d e f g h i}}`) |
| checkCoverage(t, tree, fileA, `a:{b:{[0]} c:{[0]} d:{[0]} e:{[1]} f:{[1]} g:{[2]} h:{[2]} i:{[2]}}`) |
| } |
| |
| func checkSpans(t *testing.T, got []cov.Span, expect ...cov.Span) { |
| if !reflect.DeepEqual(got, expect) { |
| t.Errorf("Spans not as expected.\nGot: %+v\nExpect: %+v", got, expect) |
| } |
| } |
| |
| func checkGroups(t *testing.T, got, expect map[cov.SpanGroupID]cov.SpanGroup) { |
| if !reflect.DeepEqual(got, expect) { |
| t.Errorf("SpanGroupss not as expected.\nGot: %+v\nExpect: %+v", got, expect) |
| } |
| } |
| |
| func checkTests(t *testing.T, tree *cov.Tree, expect string) { |
| g, e := tree.Tests().String(tree.Strings()), expect |
| if tg, te := trimWS(g), trimWS(e); tg != te { |
| t.Errorf("Tests not as expected.\nGot:\n%v\nExpect:\n%v\n------\nGot: %v\nExpect: %v", g, e, tg, te) |
| } |
| } |
| |
| func checkCoverage(t *testing.T, tree *cov.Tree, file string, expect string) { |
| g, e := tree.FileCoverage(file).String(tree.Tests(), tree.Strings()), expect |
| if tg, te := trimWS(g), trimWS(e); tg != te { |
| t.Errorf("Coverage not as expected.\nGot:\n%v\nExpect:\n%v\n------\nGot: %v\nExpect: %v", g, e, tg, te) |
| } |
| } |
| |
| func trimWS(s string) string { |
| s = strings.ReplaceAll(s, " ", "") |
| s = strings.ReplaceAll(s, "\n", "") |
| return s |
| } |
| |
| func coverage(file string, spans ...cov.Span) *cov.Coverage { |
| return &cov.Coverage{ |
| []cov.File{ |
| cov.File{ |
| Path: file, |
| Covered: spans, |
| }, |
| }, |
| } |
| } |
| |
| func spans(ids ...cov.SpanID) cov.SpanSet { |
| out := make(cov.SpanSet, len(ids)) |
| for _, id := range ids { |
| out[id] = struct{}{} |
| } |
| return out |
| } |
| |
| func TestTreeEncodeDecode(t *testing.T) { |
| orig := &cov.Tree{} |
| orig.Add(cov.Path{"a", "b"}, coverage(fileA, span0, span1)) |
| orig.Add(cov.Path{"a", "b", "d", "i"}, coverage(fileA, span0, span1)) |
| orig.Add(cov.Path{"a", "b", "e"}, coverage(fileA, span0, span1, span2)) |
| orig.Add(cov.Path{"a", "c", "g", "n"}, coverage(fileB, span0, span3)) |
| orig.Add(cov.Path{"a", "c", "g", "o"}, coverage(fileB, span0, span3)) |
| orig.Add(cov.Path{"a", "c", "f"}, coverage(fileA, span1)) |
| orig.Add(cov.Path{"a", "b", "e", "j"}, coverage(fileC, span3)) |
| orig.Add(cov.Path{"a", "b", "e", "k"}, coverage(fileA, span3)) |
| orig.Add(cov.Path{"a", "c", "f", "l", "v"}, coverage(fileA, span1, span2)) |
| orig.Add(cov.Path{"a", "c", "f", "l", "x"}, coverage(fileA, span1, span2)) |
| orig.Add(cov.Path{"a", "c", "g", "n", "z"}, coverage(fileC, span2)) |
| orig.Add(cov.Path{"a", "b"}, coverage(fileA, span0, span1)) |
| orig.Add(cov.Path{"a", "b"}, coverage(fileA, span0, span1)) |
| |
| origJSON := orig.JSON("revision goes here") |
| read, revision, err := cov.ReadJSON(strings.NewReader(origJSON)) |
| if err != nil { |
| t.Fatalf("cov.ReadJSON() failed with: %v", err) |
| } |
| readJSON := read.JSON(revision) |
| if origJSON != readJSON { |
| t.Fatalf("Encode -> Decode -> Encode produced different results:\nOriginal:\n\n%v\n\nRead:\n\n%v", origJSON, readJSON) |
| } |
| } |
