Hulk did something

[bytom/vapor.git] / vendor / github.com / miekg / dns / dnsutil / util_test.go

diff --git a/vendor/github.com/miekg/dns/dnsutil/util_test.go b/vendor/github.com/miekg/dns/dnsutil/util_test.go
new file mode 100644 (file)
index 0000000..6754789
--- /dev/null
+++ b/vendor/github.com/miekg/dns/dnsutil/util_test.go
@@ -0,0 +1,130 @@
+package dnsutil
+
+import "testing"
+
+func TestAddOrigin(t *testing.T) {
+       var tests = []struct{ e1, e2, expected string }{
+               {"@", "example.com", "example.com"},
+               {"foo", "example.com", "foo.example.com"},
+               {"foo.", "example.com", "foo."},
+               {"@", "example.com.", "example.com."},
+               {"foo", "example.com.", "foo.example.com."},
+               {"foo.", "example.com.", "foo."},
+               {"example.com", ".", "example.com."},
+               {"example.com.", ".", "example.com."},
+               // Oddball tests:
+               // In general origin should not be "" or "." but at least
+               // these tests verify we don't crash and will keep results
+               // from changing unexpectedly.
+               {"*.", "", "*."},
+               {"@", "", "@"},
+               {"foobar", "", "foobar"},
+               {"foobar.", "", "foobar."},
+               {"*.", ".", "*."},
+               {"@", ".", "."},
+               {"foobar", ".", "foobar."},
+               {"foobar.", ".", "foobar."},
+       }
+       for _, test := range tests {
+               actual := AddOrigin(test.e1, test.e2)
+               if test.expected != actual {
+                       t.Errorf("AddOrigin(%#v, %#v) expected %#v, got %#v\n", test.e1, test.e2, test.expected, actual)
+               }
+       }
+}
+
+func TestTrimDomainName(t *testing.T) {
+       // Basic tests.
+       // Try trimming "example.com" and "example.com." from typical use cases.
+       testsEx := []struct{ experiment, expected string }{
+               {"foo.example.com", "foo"},
+               {"foo.example.com.", "foo"},
+               {".foo.example.com", ".foo"},
+               {".foo.example.com.", ".foo"},
+               {"*.example.com", "*"},
+               {"example.com", "@"},
+               {"example.com.", "@"},
+               {"com.", "com."},
+               {"foo.", "foo."},
+               {"serverfault.com.", "serverfault.com."},
+               {"serverfault.com", "serverfault.com"},
+               {".foo.ronco.com", ".foo.ronco.com"},
+               {".foo.ronco.com.", ".foo.ronco.com."},
+       }
+       for _, dom := range []string{"example.com", "example.com."} {
+               for i, test := range testsEx {
+                       actual := TrimDomainName(test.experiment, dom)
+                       if test.expected != actual {
+                               t.Errorf("%d TrimDomainName(%#v, %#v): expected %v, got %v\n", i, test.experiment, dom, test.expected, actual)
+                       }
+               }
+       }
+
+       // Paranoid tests.
+       // These test shouldn't be needed but I was weary of off-by-one errors.
+       // In theory, these can't happen because there are no single-letter TLDs,
+       // but it is good to exercize the code this way.
+       tests := []struct{ experiment, expected string }{
+               {"", "@"},
+               {".", "."},
+               {"a.b.c.d.e.f.", "a.b.c.d.e"},
+               {"b.c.d.e.f.", "b.c.d.e"},
+               {"c.d.e.f.", "c.d.e"},
+               {"d.e.f.", "d.e"},
+               {"e.f.", "e"},
+               {"f.", "@"},
+               {".a.b.c.d.e.f.", ".a.b.c.d.e"},
+               {".b.c.d.e.f.", ".b.c.d.e"},
+               {".c.d.e.f.", ".c.d.e"},
+               {".d.e.f.", ".d.e"},
+               {".e.f.", ".e"},
+               {".f.", "@"},
+               {"a.b.c.d.e.f", "a.b.c.d.e"},
+               {"a.b.c.d.e.", "a.b.c.d.e."},
+               {"a.b.c.d.e", "a.b.c.d.e"},
+               {"a.b.c.d.", "a.b.c.d."},
+               {"a.b.c.d", "a.b.c.d"},
+               {"a.b.c.", "a.b.c."},
+               {"a.b.c", "a.b.c"},
+               {"a.b.", "a.b."},
+               {"a.b", "a.b"},
+               {"a.", "a."},
+               {"a", "a"},
+               {".a.b.c.d.e.f", ".a.b.c.d.e"},
+               {".a.b.c.d.e.", ".a.b.c.d.e."},
+               {".a.b.c.d.e", ".a.b.c.d.e"},
+               {".a.b.c.d.", ".a.b.c.d."},
+               {".a.b.c.d", ".a.b.c.d"},
+               {".a.b.c.", ".a.b.c."},
+               {".a.b.c", ".a.b.c"},
+               {".a.b.", ".a.b."},
+               {".a.b", ".a.b"},
+               {".a.", ".a."},
+               {".a", ".a"},
+       }
+       for _, dom := range []string{"f", "f."} {
+               for i, test := range tests {
+                       actual := TrimDomainName(test.experiment, dom)
+                       if test.expected != actual {
+                               t.Errorf("%d TrimDomainName(%#v, %#v): expected %v, got %v\n", i, test.experiment, dom, test.expected, actual)
+                       }
+               }
+       }
+
+       // Test cases for bugs found in the wild.
+       // These test cases provide both origin, s, and the expected result.
+       // If you find a bug in the while, this is probably the easiest place
+       // to add it as a test case.
+       var testsWild = []struct{ e1, e2, expected string }{
+               {"mathoverflow.net.", ".", "mathoverflow.net"},
+               {"mathoverflow.net", ".", "mathoverflow.net"},
+               {"", ".", "@"},
+               {"@", ".", "@"},
+       }
+       for i, test := range testsWild {
+               actual := TrimDomainName(test.e1, test.e2)
+               if test.expected != actual {
+                       t.Errorf("%d TrimDomainName(%#v, %#v): expected %v, got %v\n", i, test.e1, test.e2, test.expected, actual)
+               }
+       }
+}