From 962b18411893e1fffd10c2b6370ac34aba62f146 Mon Sep 17 00:00:00 2001 From: Christopher Speller Date: Tue, 23 Feb 2016 14:07:01 -0500 Subject: Updating golang dependancies (godep) --- .../src/gopkg.in/asn1-ber.v1/ber_test.go | 168 --- .../src/gopkg.in/asn1-ber.v1/header_test.go | 135 --- .../src/gopkg.in/asn1-ber.v1/identifier_test.go | 344 ------ .../src/gopkg.in/asn1-ber.v1/length_test.go | 158 --- .../src/gopkg.in/asn1-ber.v1/suite_test.go | 182 --- .../src/gopkg.in/fsnotify.v1/example_test.go | 42 - .../gopkg.in/fsnotify.v1/inotify_poller_test.go | 228 ---- .../src/gopkg.in/fsnotify.v1/inotify_test.go | 341 ------ .../src/gopkg.in/fsnotify.v1/integration_test.go | 1183 -------------------- .../gopkg.in/throttled/throttled.v1/common_test.go | 65 -- .../throttled/throttled.v1/delayer_test.go | 65 -- .../throttled/throttled.v1/interval_test.go | 114 -- .../throttled/throttled.v1/memstats_test.go | 64 -- .../gopkg.in/throttled/throttled.v1/rate_test.go | 101 -- .../throttled/throttled.v1/store/mem_test.go | 43 - .../throttled/throttled.v1/store/redis_test.go | 66 -- .../gopkg.in/throttled/throttled.v1/varyby_test.go | 56 - 17 files changed, 3355 deletions(-) delete mode 100644 Godeps/_workspace/src/gopkg.in/asn1-ber.v1/ber_test.go delete mode 100644 Godeps/_workspace/src/gopkg.in/asn1-ber.v1/header_test.go delete mode 100644 Godeps/_workspace/src/gopkg.in/asn1-ber.v1/identifier_test.go delete mode 100644 Godeps/_workspace/src/gopkg.in/asn1-ber.v1/length_test.go delete mode 100644 Godeps/_workspace/src/gopkg.in/asn1-ber.v1/suite_test.go delete mode 100644 Godeps/_workspace/src/gopkg.in/fsnotify.v1/example_test.go delete mode 100644 Godeps/_workspace/src/gopkg.in/fsnotify.v1/inotify_poller_test.go delete mode 100644 Godeps/_workspace/src/gopkg.in/fsnotify.v1/inotify_test.go delete mode 100644 Godeps/_workspace/src/gopkg.in/fsnotify.v1/integration_test.go delete mode 100644 Godeps/_workspace/src/gopkg.in/throttled/throttled.v1/common_test.go delete mode 100644 Godeps/_workspace/src/gopkg.in/throttled/throttled.v1/delayer_test.go delete mode 100644 Godeps/_workspace/src/gopkg.in/throttled/throttled.v1/interval_test.go delete mode 100644 Godeps/_workspace/src/gopkg.in/throttled/throttled.v1/memstats_test.go delete mode 100644 Godeps/_workspace/src/gopkg.in/throttled/throttled.v1/rate_test.go delete mode 100644 Godeps/_workspace/src/gopkg.in/throttled/throttled.v1/store/mem_test.go delete mode 100644 Godeps/_workspace/src/gopkg.in/throttled/throttled.v1/store/redis_test.go delete mode 100644 Godeps/_workspace/src/gopkg.in/throttled/throttled.v1/varyby_test.go (limited to 'Godeps/_workspace/src/gopkg.in') diff --git a/Godeps/_workspace/src/gopkg.in/asn1-ber.v1/ber_test.go b/Godeps/_workspace/src/gopkg.in/asn1-ber.v1/ber_test.go deleted file mode 100644 index bbd22db6d..000000000 --- a/Godeps/_workspace/src/gopkg.in/asn1-ber.v1/ber_test.go +++ /dev/null @@ -1,168 +0,0 @@ -package ber - -import ( - "bytes" - "math" - - "io" - "testing" -) - -func TestEncodeDecodeInteger(t *testing.T) { - for _, v := range []int64{0, 10, 128, 1024, math.MaxInt64, -1, -100, -128, -1024, math.MinInt64} { - enc := encodeInteger(v) - dec, err := parseInt64(enc) - if err != nil { - t.Fatalf("Error decoding %d : %s", v, err) - } - if v != dec { - t.Error("TestEncodeDecodeInteger failed for %d (got %d)", v, dec) - } - - } -} - -func TestBoolean(t *testing.T) { - var value bool = true - - packet := NewBoolean(ClassUniversal, TypePrimitive, TagBoolean, value, "first Packet, True") - - newBoolean, ok := packet.Value.(bool) - if !ok || newBoolean != value { - t.Error("error during creating packet") - } - - encodedPacket := packet.Bytes() - - newPacket := DecodePacket(encodedPacket) - - newBoolean, ok = newPacket.Value.(bool) - if !ok || newBoolean != value { - t.Error("error during decoding packet") - } - -} - -func TestInteger(t *testing.T) { - var value int64 = 10 - - packet := NewInteger(ClassUniversal, TypePrimitive, TagInteger, value, "Integer, 10") - - { - newInteger, ok := packet.Value.(int64) - if !ok || newInteger != value { - t.Error("error creating packet") - } - } - - encodedPacket := packet.Bytes() - - newPacket := DecodePacket(encodedPacket) - - { - newInteger, ok := newPacket.Value.(int64) - if !ok || int64(newInteger) != value { - t.Error("error decoding packet") - } - } -} - -func TestString(t *testing.T) { - var value string = "Hic sunt dracones" - - packet := NewString(ClassUniversal, TypePrimitive, TagOctetString, value, "String") - - newValue, ok := packet.Value.(string) - if !ok || newValue != value { - t.Error("error during creating packet") - } - - encodedPacket := packet.Bytes() - - newPacket := DecodePacket(encodedPacket) - - newValue, ok = newPacket.Value.(string) - if !ok || newValue != value { - t.Error("error during decoding packet") - } - -} - -func TestSequenceAndAppendChild(t *testing.T) { - - values := []string{ - "HIC SVNT LEONES", - "Iñtërnâtiônàlizætiøn", - "Terra Incognita", - } - - sequence := NewSequence("a sequence") - for _, s := range values { - sequence.AppendChild(NewString(ClassUniversal, TypePrimitive, TagOctetString, s, "String")) - } - - if len(sequence.Children) != len(values) { - t.Errorf("wrong length for children array should be %d, got %d", len(values), len(sequence.Children)) - } - - encodedSequence := sequence.Bytes() - - decodedSequence := DecodePacket(encodedSequence) - if len(decodedSequence.Children) != len(values) { - t.Errorf("wrong length for children array should be %d => %d", len(values), len(decodedSequence.Children)) - } - - for i, s := range values { - if decodedSequence.Children[i].Value.(string) != s { - t.Errorf("expected %d to be %q, got %q", i, s, decodedSequence.Children[i].Value.(string)) - } - } -} - -func TestReadPacket(t *testing.T) { - packet := NewString(ClassUniversal, TypePrimitive, TagOctetString, "Ad impossibilia nemo tenetur", "string") - var buffer io.ReadWriter - buffer = new(bytes.Buffer) - - buffer.Write(packet.Bytes()) - - newPacket, err := ReadPacket(buffer) - if err != nil { - t.Error("error during ReadPacket", err) - } - newPacket.ByteValue = nil - if !bytes.Equal(newPacket.ByteValue, packet.ByteValue) { - t.Error("packets should be the same") - } -} - -func TestBinaryInteger(t *testing.T) { - // data src : http://luca.ntop.org/Teaching/Appunti/asn1.html 5.7 - var data = []struct { - v int64 - e []byte - }{ - {v: 0, e: []byte{0x02, 0x01, 0x00}}, - {v: 127, e: []byte{0x02, 0x01, 0x7F}}, - {v: 128, e: []byte{0x02, 0x02, 0x00, 0x80}}, - {v: 256, e: []byte{0x02, 0x02, 0x01, 0x00}}, - {v: -128, e: []byte{0x02, 0x01, 0x80}}, - {v: -129, e: []byte{0x02, 0x02, 0xFF, 0x7F}}, - {v: math.MaxInt64, e: []byte{0x02, 0x08, 0x7F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}}, - {v: math.MinInt64, e: []byte{0x02, 0x08, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}, - } - - for _, d := range data { - if b := NewInteger(ClassUniversal, TypePrimitive, TagInteger, int64(d.v), "").Bytes(); !bytes.Equal(d.e, b) { - t.Errorf("Wrong binary generated for %d : got % X, expected % X", d.v, b, d.e) - } - } -} - -func TestBinaryOctetString(t *testing.T) { - // data src : http://luca.ntop.org/Teaching/Appunti/asn1.html 5.10 - - if !bytes.Equal([]byte{0x04, 0x08, 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef}, NewString(ClassUniversal, TypePrimitive, TagOctetString, "\x01\x23\x45\x67\x89\xab\xcd\xef", "").Bytes()) { - t.Error("wrong binary generated") - } -} diff --git a/Godeps/_workspace/src/gopkg.in/asn1-ber.v1/header_test.go b/Godeps/_workspace/src/gopkg.in/asn1-ber.v1/header_test.go deleted file mode 100644 index cac1e2e2b..000000000 --- a/Godeps/_workspace/src/gopkg.in/asn1-ber.v1/header_test.go +++ /dev/null @@ -1,135 +0,0 @@ -package ber - -import ( - "bytes" - "io" - "testing" -) - -func TestReadHeader(t *testing.T) { - testcases := map[string]struct { - Data []byte - ExpectedIdentifier Identifier - ExpectedLength int - ExpectedBytesRead int - ExpectedError string - }{ - "empty": { - Data: []byte{}, - ExpectedIdentifier: Identifier{}, - ExpectedLength: 0, - ExpectedBytesRead: 0, - ExpectedError: io.ErrUnexpectedEOF.Error(), - }, - - "valid short form": { - Data: []byte{ - byte(ClassUniversal) | byte(TypePrimitive) | byte(TagCharacterString), - 127, - }, - ExpectedIdentifier: Identifier{ - ClassType: ClassUniversal, - TagType: TypePrimitive, - Tag: TagCharacterString, - }, - ExpectedLength: 127, - ExpectedBytesRead: 2, - ExpectedError: "", - }, - - "valid long form": { - Data: []byte{ - // 2-byte encoding of tag - byte(ClassUniversal) | byte(TypePrimitive) | byte(HighTag), - byte(TagCharacterString), - - // 2-byte encoding of length - LengthLongFormBitmask | 1, - 127, - }, - ExpectedIdentifier: Identifier{ - ClassType: ClassUniversal, - TagType: TypePrimitive, - Tag: TagCharacterString, - }, - ExpectedLength: 127, - ExpectedBytesRead: 4, - ExpectedError: "", - }, - - "valid indefinite length": { - Data: []byte{ - byte(ClassUniversal) | byte(TypeConstructed) | byte(TagCharacterString), - LengthLongFormBitmask, - }, - ExpectedIdentifier: Identifier{ - ClassType: ClassUniversal, - TagType: TypeConstructed, - Tag: TagCharacterString, - }, - ExpectedLength: LengthIndefinite, - ExpectedBytesRead: 2, - ExpectedError: "", - }, - - "invalid indefinite length": { - Data: []byte{ - byte(ClassUniversal) | byte(TypePrimitive) | byte(TagCharacterString), - LengthLongFormBitmask, - }, - ExpectedIdentifier: Identifier{}, - ExpectedLength: 0, - ExpectedBytesRead: 2, - ExpectedError: "indefinite length used with primitive type", - }, - } - - for k, tc := range testcases { - reader := bytes.NewBuffer(tc.Data) - identifier, length, read, err := readHeader(reader) - - if err != nil { - if tc.ExpectedError == "" { - t.Errorf("%s: unexpected error: %v", k, err) - } else if err.Error() != tc.ExpectedError { - t.Errorf("%s: expected error %v, got %v", k, tc.ExpectedError, err) - } - } else if tc.ExpectedError != "" { - t.Errorf("%s: expected error %v, got none", k, tc.ExpectedError) - continue - } - - if read != tc.ExpectedBytesRead { - t.Errorf("%s: expected read %d, got %d", k, tc.ExpectedBytesRead, read) - } - - if identifier.ClassType != tc.ExpectedIdentifier.ClassType { - t.Errorf("%s: expected class type %d (%s), got %d (%s)", k, - tc.ExpectedIdentifier.ClassType, - ClassMap[tc.ExpectedIdentifier.ClassType], - identifier.ClassType, - ClassMap[identifier.ClassType], - ) - } - if identifier.TagType != tc.ExpectedIdentifier.TagType { - t.Errorf("%s: expected tag type %d (%s), got %d (%s)", k, - tc.ExpectedIdentifier.TagType, - TypeMap[tc.ExpectedIdentifier.TagType], - identifier.TagType, - TypeMap[identifier.TagType], - ) - } - if identifier.Tag != tc.ExpectedIdentifier.Tag { - t.Errorf("%s: expected tag %d (%s), got %d (%s)", k, - tc.ExpectedIdentifier.Tag, - tagMap[tc.ExpectedIdentifier.Tag], - identifier.Tag, - tagMap[identifier.Tag], - ) - } - - if length != tc.ExpectedLength { - t.Errorf("%s: expected length %d, got %d", k, tc.ExpectedLength, length) - } - } -} diff --git a/Godeps/_workspace/src/gopkg.in/asn1-ber.v1/identifier_test.go b/Godeps/_workspace/src/gopkg.in/asn1-ber.v1/identifier_test.go deleted file mode 100644 index 7169362e2..000000000 --- a/Godeps/_workspace/src/gopkg.in/asn1-ber.v1/identifier_test.go +++ /dev/null @@ -1,344 +0,0 @@ -package ber - -import ( - "bytes" - "io" - "math" - "testing" -) - -func TestReadIdentifier(t *testing.T) { - testcases := map[string]struct { - Data []byte - - ExpectedIdentifier Identifier - ExpectedBytesRead int - ExpectedError string - }{ - "empty": { - Data: []byte{}, - ExpectedBytesRead: 0, - ExpectedError: io.ErrUnexpectedEOF.Error(), - }, - - "universal primitive eoc": { - Data: []byte{byte(ClassUniversal) | byte(TypePrimitive) | byte(TagEOC)}, - ExpectedIdentifier: Identifier{ - ClassType: ClassUniversal, - TagType: TypePrimitive, - Tag: TagEOC, - }, - ExpectedBytesRead: 1, - }, - "universal primitive character string": { - Data: []byte{byte(ClassUniversal) | byte(TypePrimitive) | byte(TagCharacterString)}, - ExpectedIdentifier: Identifier{ - ClassType: ClassUniversal, - TagType: TypePrimitive, - Tag: TagCharacterString, - }, - ExpectedBytesRead: 1, - }, - - "universal constructed bit string": { - Data: []byte{byte(ClassUniversal) | byte(TypeConstructed) | byte(TagBitString)}, - ExpectedIdentifier: Identifier{ - ClassType: ClassUniversal, - TagType: TypeConstructed, - Tag: TagBitString, - }, - ExpectedBytesRead: 1, - }, - "universal constructed character string": { - Data: []byte{byte(ClassUniversal) | byte(TypeConstructed) | byte(TagCharacterString)}, - ExpectedIdentifier: Identifier{ - ClassType: ClassUniversal, - TagType: TypeConstructed, - Tag: TagCharacterString, - }, - ExpectedBytesRead: 1, - }, - - "application constructed object descriptor": { - Data: []byte{byte(ClassApplication) | byte(TypeConstructed) | byte(TagObjectDescriptor)}, - ExpectedIdentifier: Identifier{ - ClassType: ClassApplication, - TagType: TypeConstructed, - Tag: TagObjectDescriptor, - }, - ExpectedBytesRead: 1, - }, - "context constructed object descriptor": { - Data: []byte{byte(ClassContext) | byte(TypeConstructed) | byte(TagObjectDescriptor)}, - ExpectedIdentifier: Identifier{ - ClassType: ClassContext, - TagType: TypeConstructed, - Tag: TagObjectDescriptor, - }, - ExpectedBytesRead: 1, - }, - "private constructed object descriptor": { - Data: []byte{byte(ClassPrivate) | byte(TypeConstructed) | byte(TagObjectDescriptor)}, - ExpectedIdentifier: Identifier{ - ClassType: ClassPrivate, - TagType: TypeConstructed, - Tag: TagObjectDescriptor, - }, - ExpectedBytesRead: 1, - }, - - "high-tag-number tag missing bytes": { - Data: []byte{byte(ClassUniversal) | byte(TypeConstructed) | byte(HighTag)}, - ExpectedError: io.ErrUnexpectedEOF.Error(), - ExpectedBytesRead: 1, - }, - "high-tag-number tag invalid first byte": { - Data: []byte{byte(ClassUniversal) | byte(TypeConstructed) | byte(HighTag), 0x0}, - ExpectedError: "invalid first high-tag-number tag byte", - ExpectedBytesRead: 2, - }, - "high-tag-number tag invalid first byte with continue bit": { - Data: []byte{byte(ClassUniversal) | byte(TypeConstructed) | byte(HighTag), byte(HighTagContinueBitmask)}, - ExpectedError: "invalid first high-tag-number tag byte", - ExpectedBytesRead: 2, - }, - "high-tag-number tag continuation missing bytes": { - Data: []byte{byte(ClassUniversal) | byte(TypeConstructed) | byte(HighTag), byte(HighTagContinueBitmask | 0x1)}, - ExpectedError: io.ErrUnexpectedEOF.Error(), - ExpectedBytesRead: 2, - }, - "high-tag-number tag overflow": { - Data: []byte{ - byte(ClassUniversal) | byte(TypeConstructed) | byte(HighTag), - byte(HighTagContinueBitmask | 0x1), - byte(HighTagContinueBitmask | 0x1), - byte(HighTagContinueBitmask | 0x1), - byte(HighTagContinueBitmask | 0x1), - byte(HighTagContinueBitmask | 0x1), - byte(HighTagContinueBitmask | 0x1), - byte(HighTagContinueBitmask | 0x1), - byte(HighTagContinueBitmask | 0x1), - byte(HighTagContinueBitmask | 0x1), - byte(0x1), - }, - ExpectedError: "high-tag-number tag overflow", - ExpectedBytesRead: 11, - }, - "max high-tag-number tag": { - Data: []byte{ - byte(ClassUniversal) | byte(TypeConstructed) | byte(HighTag), - byte(HighTagContinueBitmask | 0x7f), - byte(HighTagContinueBitmask | 0x7f), - byte(HighTagContinueBitmask | 0x7f), - byte(HighTagContinueBitmask | 0x7f), - byte(HighTagContinueBitmask | 0x7f), - byte(HighTagContinueBitmask | 0x7f), - byte(HighTagContinueBitmask | 0x7f), - byte(HighTagContinueBitmask | 0x7f), - byte(0x7f), - }, - ExpectedIdentifier: Identifier{ - ClassType: ClassUniversal, - TagType: TypeConstructed, - Tag: Tag(0x7FFFFFFFFFFFFFFF), // 01111111...(63)...11111b - }, - ExpectedBytesRead: 10, - }, - "high-tag-number encoding of low-tag value": { - Data: []byte{ - byte(ClassUniversal) | byte(TypeConstructed) | byte(HighTag), - byte(TagObjectDescriptor), - }, - ExpectedIdentifier: Identifier{ - ClassType: ClassUniversal, - TagType: TypeConstructed, - Tag: TagObjectDescriptor, - }, - ExpectedBytesRead: 2, - }, - "max high-tag-number tag ignores extra data": { - Data: []byte{ - byte(ClassUniversal) | byte(TypeConstructed) | byte(HighTag), - byte(HighTagContinueBitmask | 0x7f), - byte(HighTagContinueBitmask | 0x7f), - byte(HighTagContinueBitmask | 0x7f), - byte(HighTagContinueBitmask | 0x7f), - byte(HighTagContinueBitmask | 0x7f), - byte(HighTagContinueBitmask | 0x7f), - byte(HighTagContinueBitmask | 0x7f), - byte(HighTagContinueBitmask | 0x7f), - byte(0x7f), - byte(0x01), // extra data, shouldn't be read - byte(0x02), // extra data, shouldn't be read - byte(0x03), // extra data, shouldn't be read - }, - ExpectedIdentifier: Identifier{ - ClassType: ClassUniversal, - TagType: TypeConstructed, - Tag: Tag(0x7FFFFFFFFFFFFFFF), // 01111111...(63)...11111b - }, - ExpectedBytesRead: 10, - }, - } - - for k, tc := range testcases { - reader := bytes.NewBuffer(tc.Data) - identifier, read, err := readIdentifier(reader) - - if err != nil { - if tc.ExpectedError == "" { - t.Errorf("%s: unexpected error: %v", k, err) - } else if err.Error() != tc.ExpectedError { - t.Errorf("%s: expected error %v, got %v", k, tc.ExpectedError, err) - } - } else if tc.ExpectedError != "" { - t.Errorf("%s: expected error %v, got none", k, tc.ExpectedError) - continue - } - - if read != tc.ExpectedBytesRead { - t.Errorf("%s: expected read %d, got %d", k, tc.ExpectedBytesRead, read) - } - - if identifier.ClassType != tc.ExpectedIdentifier.ClassType { - t.Errorf("%s: expected class type %d (%s), got %d (%s)", k, - tc.ExpectedIdentifier.ClassType, - ClassMap[tc.ExpectedIdentifier.ClassType], - identifier.ClassType, - ClassMap[identifier.ClassType], - ) - } - if identifier.TagType != tc.ExpectedIdentifier.TagType { - t.Errorf("%s: expected tag type %d (%s), got %d (%s)", k, - tc.ExpectedIdentifier.TagType, - TypeMap[tc.ExpectedIdentifier.TagType], - identifier.TagType, - TypeMap[identifier.TagType], - ) - } - if identifier.Tag != tc.ExpectedIdentifier.Tag { - t.Errorf("%s: expected tag %d (%s), got %d (%s)", k, - tc.ExpectedIdentifier.Tag, - tagMap[tc.ExpectedIdentifier.Tag], - identifier.Tag, - tagMap[identifier.Tag], - ) - } - } -} - -func TestEncodeIdentifier(t *testing.T) { - testcases := map[string]struct { - Identifier Identifier - ExpectedBytes []byte - }{ - "universal primitive eoc": { - Identifier: Identifier{ - ClassType: ClassUniversal, - TagType: TypePrimitive, - Tag: TagEOC, - }, - ExpectedBytes: []byte{byte(ClassUniversal) | byte(TypePrimitive) | byte(TagEOC)}, - }, - "universal primitive character string": { - Identifier: Identifier{ - ClassType: ClassUniversal, - TagType: TypePrimitive, - Tag: TagCharacterString, - }, - ExpectedBytes: []byte{byte(ClassUniversal) | byte(TypePrimitive) | byte(TagCharacterString)}, - }, - - "universal constructed bit string": { - Identifier: Identifier{ - ClassType: ClassUniversal, - TagType: TypeConstructed, - Tag: TagBitString, - }, - ExpectedBytes: []byte{byte(ClassUniversal) | byte(TypeConstructed) | byte(TagBitString)}, - }, - "universal constructed character string": { - Identifier: Identifier{ - ClassType: ClassUniversal, - TagType: TypeConstructed, - Tag: TagCharacterString, - }, - ExpectedBytes: []byte{byte(ClassUniversal) | byte(TypeConstructed) | byte(TagCharacterString)}, - }, - - "application constructed object descriptor": { - Identifier: Identifier{ - ClassType: ClassApplication, - TagType: TypeConstructed, - Tag: TagObjectDescriptor, - }, - ExpectedBytes: []byte{byte(ClassApplication) | byte(TypeConstructed) | byte(TagObjectDescriptor)}, - }, - "context constructed object descriptor": { - Identifier: Identifier{ - ClassType: ClassContext, - TagType: TypeConstructed, - Tag: TagObjectDescriptor, - }, - ExpectedBytes: []byte{byte(ClassContext) | byte(TypeConstructed) | byte(TagObjectDescriptor)}, - }, - "private constructed object descriptor": { - Identifier: Identifier{ - ClassType: ClassPrivate, - TagType: TypeConstructed, - Tag: TagObjectDescriptor, - }, - ExpectedBytes: []byte{byte(ClassPrivate) | byte(TypeConstructed) | byte(TagObjectDescriptor)}, - }, - - "max low-tag-number tag": { - Identifier: Identifier{ - ClassType: ClassUniversal, - TagType: TypeConstructed, - Tag: TagBMPString, - }, - ExpectedBytes: []byte{ - byte(ClassUniversal) | byte(TypeConstructed) | byte(TagBMPString), - }, - }, - - "min high-tag-number tag": { - Identifier: Identifier{ - ClassType: ClassUniversal, - TagType: TypeConstructed, - Tag: TagBMPString + 1, - }, - ExpectedBytes: []byte{ - byte(ClassUniversal) | byte(TypeConstructed) | byte(HighTag), - byte(TagBMPString + 1), - }, - }, - - "max high-tag-number tag": { - Identifier: Identifier{ - ClassType: ClassUniversal, - TagType: TypeConstructed, - Tag: Tag(math.MaxInt64), - }, - ExpectedBytes: []byte{ - byte(ClassUniversal) | byte(TypeConstructed) | byte(HighTag), - byte(HighTagContinueBitmask | 0x7f), - byte(HighTagContinueBitmask | 0x7f), - byte(HighTagContinueBitmask | 0x7f), - byte(HighTagContinueBitmask | 0x7f), - byte(HighTagContinueBitmask | 0x7f), - byte(HighTagContinueBitmask | 0x7f), - byte(HighTagContinueBitmask | 0x7f), - byte(HighTagContinueBitmask | 0x7f), - byte(0x7f), - }, - }, - } - - for k, tc := range testcases { - b := encodeIdentifier(tc.Identifier) - if bytes.Compare(tc.ExpectedBytes, b) != 0 { - t.Errorf("%s: Expected\n\t%#v\ngot\n\t%#v", k, tc.ExpectedBytes, b) - } - } -} diff --git a/Godeps/_workspace/src/gopkg.in/asn1-ber.v1/length_test.go b/Godeps/_workspace/src/gopkg.in/asn1-ber.v1/length_test.go deleted file mode 100644 index afe0e8037..000000000 --- a/Godeps/_workspace/src/gopkg.in/asn1-ber.v1/length_test.go +++ /dev/null @@ -1,158 +0,0 @@ -package ber - -import ( - "bytes" - "io" - "math" - "testing" -) - -func TestReadLength(t *testing.T) { - testcases := map[string]struct { - Data []byte - - ExpectedLength int - ExpectedBytesRead int - ExpectedError string - }{ - "empty": { - Data: []byte{}, - ExpectedBytesRead: 0, - ExpectedError: io.ErrUnexpectedEOF.Error(), - }, - "invalid first byte": { - Data: []byte{0xFF}, - ExpectedBytesRead: 1, - ExpectedError: "invalid length byte 0xff", - }, - - "indefinite form": { - Data: []byte{LengthLongFormBitmask}, - ExpectedLength: LengthIndefinite, - ExpectedBytesRead: 1, - }, - - "short-definite-form zero length": { - Data: []byte{0}, - ExpectedLength: 0, - ExpectedBytesRead: 1, - }, - "short-definite-form length 1": { - Data: []byte{1}, - ExpectedLength: 1, - ExpectedBytesRead: 1, - }, - "short-definite-form max length": { - Data: []byte{127}, - ExpectedLength: 127, - ExpectedBytesRead: 1, - }, - - "long-definite-form missing bytes": { - Data: []byte{LengthLongFormBitmask | 1}, - ExpectedBytesRead: 1, - ExpectedError: io.ErrUnexpectedEOF.Error(), - }, - "long-definite-form overflow": { - Data: []byte{LengthLongFormBitmask | 9}, - ExpectedBytesRead: 1, - ExpectedError: "long-form length overflow", - }, - "long-definite-form zero length": { - Data: []byte{LengthLongFormBitmask | 1, 0x0}, - ExpectedLength: 0, - ExpectedBytesRead: 2, - }, - "long-definite-form length 127": { - Data: []byte{LengthLongFormBitmask | 1, 127}, - ExpectedLength: 127, - ExpectedBytesRead: 2, - }, - "long-definite-form max length": { - Data: []byte{ - LengthLongFormBitmask | 8, - 0x7F, - 0xFF, - 0xFF, - 0xFF, - 0xFF, - 0xFF, - 0xFF, - 0xFF, - }, - ExpectedLength: math.MaxInt64, - ExpectedBytesRead: 9, - }, - } - - for k, tc := range testcases { - reader := bytes.NewBuffer(tc.Data) - length, read, err := readLength(reader) - - if err != nil { - if tc.ExpectedError == "" { - t.Errorf("%s: unexpected error: %v", k, err) - } else if err.Error() != tc.ExpectedError { - t.Errorf("%s: expected error %v, got %v", k, tc.ExpectedError, err) - } - } else if tc.ExpectedError != "" { - t.Errorf("%s: expected error %v, got none", k, tc.ExpectedError) - continue - } - - if read != tc.ExpectedBytesRead { - t.Errorf("%s: expected read %d, got %d", k, tc.ExpectedBytesRead, read) - } - - if length != tc.ExpectedLength { - t.Errorf("%s: expected length %d, got %d", k, tc.ExpectedLength, length) - } - } -} - -func TestEncodeLength(t *testing.T) { - testcases := map[string]struct { - Length int - ExpectedBytes []byte - }{ - "0": { - Length: 0, - ExpectedBytes: []byte{0}, - }, - "1": { - Length: 1, - ExpectedBytes: []byte{1}, - }, - - "max short-form length": { - Length: 127, - ExpectedBytes: []byte{127}, - }, - "min long-form length": { - Length: 128, - ExpectedBytes: []byte{LengthLongFormBitmask | 1, 128}, - }, - - "max long-form length": { - Length: math.MaxInt64, - ExpectedBytes: []byte{ - LengthLongFormBitmask | 8, - 0x7F, - 0xFF, - 0xFF, - 0xFF, - 0xFF, - 0xFF, - 0xFF, - 0xFF, - }, - }, - } - - for k, tc := range testcases { - b := encodeLength(tc.Length) - if bytes.Compare(tc.ExpectedBytes, b) != 0 { - t.Errorf("%s: Expected\n\t%#v\ngot\n\t%#v", k, tc.ExpectedBytes, b) - } - } -} diff --git a/Godeps/_workspace/src/gopkg.in/asn1-ber.v1/suite_test.go b/Godeps/_workspace/src/gopkg.in/asn1-ber.v1/suite_test.go deleted file mode 100644 index ace8e6705..000000000 --- a/Godeps/_workspace/src/gopkg.in/asn1-ber.v1/suite_test.go +++ /dev/null @@ -1,182 +0,0 @@ -package ber - -import ( - "bytes" - "io" - "io/ioutil" - "testing" -) - -var errEOF = io.ErrUnexpectedEOF.Error() - -// Tests from http://www.strozhevsky.com/free_docs/free_asn1_testsuite_descr.pdf -// Source files and descriptions at http://www.strozhevsky.com/free_docs/TEST_SUITE.zip -var testcases = []struct { - // File contains the path to the BER-encoded file - File string - // Error indicates whether a decoding error is expected - Error string - // AbnormalEncoding indicates whether a normalized re-encoding is expected to differ from the original source - AbnormalEncoding bool - // IndefiniteEncoding indicates the source file used indefinite-length encoding, so the re-encoding is expected to differ (since the length is known) - IndefiniteEncoding bool -}{ - // Common blocks - {File: "tests/tc1.ber", Error: "high-tag-number tag overflow"}, - {File: "tests/tc2.ber", Error: errEOF}, - {File: "tests/tc3.ber", Error: errEOF}, - {File: "tests/tc4.ber", Error: "invalid length byte 0xff"}, - {File: "tests/tc5.ber", Error: "", AbnormalEncoding: true}, - // Real numbers (some expected failures are disabled until support is added) - {File: "tests/tc6.ber", Error: ""}, // Error: "REAL value +0 must be encoded with zero-length value block"}, - {File: "tests/tc7.ber", Error: ""}, // Error: "REAL value -0 must be encoded as a special value"}, - {File: "tests/tc8.ber", Error: ""}, - {File: "tests/tc9.ber", Error: ""}, // Error: "Bits 6 and 5 of information octet for REAL are equal to 11" - {File: "tests/tc10.ber", Error: ""}, - {File: "tests/tc11.ber", Error: ""}, // Error: "Incorrect NR form" - {File: "tests/tc12.ber", Error: ""}, // Error: "Encoding of "special value" not from ASN.1 standard" - {File: "tests/tc13.ber", Error: errEOF}, - {File: "tests/tc14.ber", Error: errEOF}, - {File: "tests/tc15.ber", Error: ""}, // Error: "Too big value of exponent" - {File: "tests/tc16.ber", Error: ""}, // Error: "Too big value of mantissa" - {File: "tests/tc17.ber", Error: ""}, // Error: "Too big values for exponent and mantissa + using of "scaling factor" value" - // Integers - {File: "tests/tc18.ber", Error: ""}, - {File: "tests/tc19.ber", Error: errEOF}, - {File: "tests/tc20.ber", Error: ""}, - // Object identifiers - {File: "tests/tc21.ber", Error: ""}, - {File: "tests/tc22.ber", Error: ""}, - {File: "tests/tc23.ber", Error: errEOF}, - {File: "tests/tc24.ber", Error: ""}, - // Booleans - {File: "tests/tc25.ber", Error: ""}, - {File: "tests/tc26.ber", Error: ""}, - {File: "tests/tc27.ber", Error: errEOF}, - {File: "tests/tc28.ber", Error: ""}, - {File: "tests/tc29.ber", Error: ""}, - // Null - {File: "tests/tc30.ber", Error: ""}, - {File: "tests/tc31.ber", Error: errEOF}, - {File: "tests/tc32.ber", Error: ""}, - // Bitstring (some expected failures are disabled until support is added) - {File: "tests/tc33.ber", Error: ""}, // Error: "Too big value for "unused bits"" - {File: "tests/tc34.ber", Error: errEOF}, - {File: "tests/tc35.ber", Error: "", IndefiniteEncoding: true}, // Error: "Using of different from BIT STRING types as internal types for constructive encoding" - {File: "tests/tc36.ber", Error: "", IndefiniteEncoding: true}, // Error: "Using of "unused bits" in internal BIT STRINGs with constructive form of encoding" - {File: "tests/tc37.ber", Error: ""}, - {File: "tests/tc38.ber", Error: "", IndefiniteEncoding: true}, - {File: "tests/tc39.ber", Error: ""}, - {File: "tests/tc40.ber", Error: ""}, - // Octet string (some expected failures are disabled until support is added) - {File: "tests/tc41.ber", Error: "", IndefiniteEncoding: true}, // Error: "Using of different from OCTET STRING types as internal types for constructive encoding" - {File: "tests/tc42.ber", Error: errEOF}, - {File: "tests/tc43.ber", Error: errEOF}, - {File: "tests/tc44.ber", Error: ""}, - {File: "tests/tc45.ber", Error: ""}, - // Bitstring - {File: "tests/tc46.ber", Error: "indefinite length used with primitive type"}, - {File: "tests/tc47.ber", Error: "eoc child not allowed with definite length"}, - {File: "tests/tc48.ber", Error: "", IndefiniteEncoding: true}, // Error: "Using of more than 7 "unused bits" in BIT STRING with constrictive encoding form" -} - -func TestSuiteDecodePacket(t *testing.T) { - // Debug = true - for _, tc := range testcases { - file := tc.File - - dataIn, err := ioutil.ReadFile(file) - if err != nil { - t.Errorf("%s: %v", file, err) - continue - } - - // fmt.Printf("%s: decode %d\n", file, len(dataIn)) - packet, err := DecodePacketErr(dataIn) - if err != nil { - if tc.Error == "" { - t.Errorf("%s: unexpected error during DecodePacket: %v", file, err) - } else if tc.Error != err.Error() { - t.Errorf("%s: expected error %q during DecodePacket, got %q", file, tc.Error, err) - } - continue - } - if tc.Error != "" { - t.Errorf("%s: expected error %q, got none", file, tc.Error) - continue - } - - dataOut := packet.Bytes() - if tc.AbnormalEncoding || tc.IndefiniteEncoding { - // Abnormal encodings and encodings that used indefinite length should re-encode differently - if bytes.Equal(dataOut, dataIn) { - t.Errorf("%s: data should have been re-encoded differently", file) - } - } else if !bytes.Equal(dataOut, dataIn) { - // Make sure the serialized data matches the source - t.Errorf("%s: data should be the same", file) - } - - packet, err = DecodePacketErr(dataOut) - if err != nil { - t.Errorf("%s: unexpected error: %v", file, err) - continue - } - - // Make sure the re-serialized data matches our original serialization - dataOut2 := packet.Bytes() - if !bytes.Equal(dataOut, dataOut2) { - t.Errorf("%s: data should be the same", file) - } - } -} - -func TestSuiteReadPacket(t *testing.T) { - for _, tc := range testcases { - file := tc.File - - dataIn, err := ioutil.ReadFile(file) - if err != nil { - t.Errorf("%s: %v", file, err) - continue - } - - buffer := bytes.NewBuffer(dataIn) - packet, err := ReadPacket(buffer) - if err != nil { - if tc.Error == "" { - t.Errorf("%s: unexpected error during ReadPacket: %v", file, err) - } else if tc.Error != err.Error() { - t.Errorf("%s: expected error %q during ReadPacket, got %q", file, tc.Error, err) - } - continue - } - if tc.Error != "" { - t.Errorf("%s: expected error %q, got none", file, tc.Error) - continue - } - - dataOut := packet.Bytes() - if tc.AbnormalEncoding || tc.IndefiniteEncoding { - // Abnormal encodings and encodings that used indefinite length should re-encode differently - if bytes.Equal(dataOut, dataIn) { - t.Errorf("%s: data should have been re-encoded differently", file) - } - } else if !bytes.Equal(dataOut, dataIn) { - // Make sure the serialized data matches the source - t.Errorf("%s: data should be the same", file) - } - - packet, err = DecodePacketErr(dataOut) - if err != nil { - t.Errorf("%s: unexpected error: %v", file, err) - continue - } - - // Make sure the re-serialized data matches our original serialization - dataOut2 := packet.Bytes() - if !bytes.Equal(dataOut, dataOut2) { - t.Errorf("%s: data should be the same", file) - } - } -} diff --git a/Godeps/_workspace/src/gopkg.in/fsnotify.v1/example_test.go b/Godeps/_workspace/src/gopkg.in/fsnotify.v1/example_test.go deleted file mode 100644 index 306379660..000000000 --- a/Godeps/_workspace/src/gopkg.in/fsnotify.v1/example_test.go +++ /dev/null @@ -1,42 +0,0 @@ -// Copyright 2012 The Go Authors. All rights reserved. -// Use of this source code is governed by a BSD-style -// license that can be found in the LICENSE file. - -// +build !plan9,!solaris - -package fsnotify_test - -import ( - "log" - - "github.com/go-fsnotify/fsnotify" -) - -func ExampleNewWatcher() { - watcher, err := fsnotify.NewWatcher() - if err != nil { - log.Fatal(err) - } - defer watcher.Close() - - done := make(chan bool) - go func() { - for { - select { - case event := <-watcher.Events: - log.Println("event:", event) - if event.Op&fsnotify.Write == fsnotify.Write { - log.Println("modified file:", event.Name) - } - case err := <-watcher.Errors: - log.Println("error:", err) - } - } - }() - - err = watcher.Add("/tmp/foo") - if err != nil { - log.Fatal(err) - } - <-done -} diff --git a/Godeps/_workspace/src/gopkg.in/fsnotify.v1/inotify_poller_test.go b/Godeps/_workspace/src/gopkg.in/fsnotify.v1/inotify_poller_test.go deleted file mode 100644 index af9f407f8..000000000 --- a/Godeps/_workspace/src/gopkg.in/fsnotify.v1/inotify_poller_test.go +++ /dev/null @@ -1,228 +0,0 @@ -// Copyright 2015 The Go Authors. All rights reserved. -// Use of this source code is governed by a BSD-style -// license that can be found in the LICENSE file. - -// +build linux - -package fsnotify - -import ( - "syscall" - "testing" - "time" -) - -type testFd [2]int - -func makeTestFd(t *testing.T) testFd { - var tfd testFd - errno := syscall.Pipe(tfd[:]) - if errno != nil { - t.Fatalf("Failed to create pipe: %v", errno) - } - return tfd -} - -func (tfd testFd) fd() int { - return tfd[0] -} - -func (tfd testFd) closeWrite(t *testing.T) { - errno := syscall.Close(tfd[1]) - if errno != nil { - t.Fatalf("Failed to close write end of pipe: %v", errno) - } -} - -func (tfd testFd) put(t *testing.T) { - buf := make([]byte, 10) - _, errno := syscall.Write(tfd[1], buf) - if errno != nil { - t.Fatalf("Failed to write to pipe: %v", errno) - } -} - -func (tfd testFd) get(t *testing.T) { - buf := make([]byte, 10) - _, errno := syscall.Read(tfd[0], buf) - if errno != nil { - t.Fatalf("Failed to read from pipe: %v", errno) - } -} - -func (tfd testFd) close() { - syscall.Close(tfd[1]) - syscall.Close(tfd[0]) -} - -func makePoller(t *testing.T) (testFd, *fdPoller) { - tfd := makeTestFd(t) - poller, err := newFdPoller(tfd.fd()) - if err != nil { - t.Fatalf("Failed to create poller: %v", err) - } - return tfd, poller -} - -func TestPollerWithBadFd(t *testing.T) { - _, err := newFdPoller(-1) - if err != syscall.EBADF { - t.Fatalf("Expected EBADF, got: %v", err) - } -} - -func TestPollerWithData(t *testing.T) { - tfd, poller := makePoller(t) - defer tfd.close() - defer poller.close() - - tfd.put(t) - ok, err := poller.wait() - if err != nil { - t.Fatalf("poller failed: %v", err) - } - if !ok { - t.Fatalf("expected poller to return true") - } - tfd.get(t) -} - -func TestPollerWithWakeup(t *testing.T) { - tfd, poller := makePoller(t) - defer tfd.close() - defer poller.close() - - err := poller.wake() - if err != nil { - t.Fatalf("wake failed: %v", err) - } - ok, err := poller.wait() - if err != nil { - t.Fatalf("poller failed: %v", err) - } - if ok { - t.Fatalf("expected poller to return false") - } -} - -func TestPollerWithClose(t *testing.T) { - tfd, poller := makePoller(t) - defer tfd.close() - defer poller.close() - - tfd.closeWrite(t) - ok, err := poller.wait() - if err != nil { - t.Fatalf("poller failed: %v", err) - } - if !ok { - t.Fatalf("expected poller to return true") - } -} - -func TestPollerWithWakeupAndData(t *testing.T) { - tfd, poller := makePoller(t) - defer tfd.close() - defer poller.close() - - tfd.put(t) - err := poller.wake() - if err != nil { - t.Fatalf("wake failed: %v", err) - } - - // both data and wakeup - ok, err := poller.wait() - if err != nil { - t.Fatalf("poller failed: %v", err) - } - if !ok { - t.Fatalf("expected poller to return true") - } - - // data is still in the buffer, wakeup is cleared - ok, err = poller.wait() - if err != nil { - t.Fatalf("poller failed: %v", err) - } - if !ok { - t.Fatalf("expected poller to return true") - } - - tfd.get(t) - // data is gone, only wakeup now - err = poller.wake() - if err != nil { - t.Fatalf("wake failed: %v", err) - } - ok, err = poller.wait() - if err != nil { - t.Fatalf("poller failed: %v", err) - } - if ok { - t.Fatalf("expected poller to return false") - } -} - -func TestPollerConcurrent(t *testing.T) { - tfd, poller := makePoller(t) - defer tfd.close() - defer poller.close() - - oks := make(chan bool) - live := make(chan bool) - defer close(live) - go func() { - defer close(oks) - for { - ok, err := poller.wait() - if err != nil { - t.Fatalf("poller failed: %v", err) - } - oks <- ok - if !<-live { - return - } - } - }() - - // Try a write - select { - case <-time.After(50 * time.Millisecond): - case <-oks: - t.Fatalf("poller did not wait") - } - tfd.put(t) - if !<-oks { - t.Fatalf("expected true") - } - tfd.get(t) - live <- true - - // Try a wakeup - select { - case <-time.After(50 * time.Millisecond): - case <-oks: - t.Fatalf("poller did not wait") - } - err := poller.wake() - if err != nil { - t.Fatalf("wake failed: %v", err) - } - if <-oks { - t.Fatalf("expected false") - } - live <- true - - // Try a close - select { - case <-time.After(50 * time.Millisecond): - case <-oks: - t.Fatalf("poller did not wait") - } - tfd.closeWrite(t) - if !<-oks { - t.Fatalf("expected true") - } - tfd.get(t) -} diff --git a/Godeps/_workspace/src/gopkg.in/fsnotify.v1/inotify_test.go b/Godeps/_workspace/src/gopkg.in/fsnotify.v1/inotify_test.go deleted file mode 100644 index 4b5c4b184..000000000 --- a/Godeps/_workspace/src/gopkg.in/fsnotify.v1/inotify_test.go +++ /dev/null @@ -1,341 +0,0 @@ -// Copyright 2015 The Go Authors. All rights reserved. -// Use of this source code is governed by a BSD-style -// license that can be found in the LICENSE file. - -// +build linux - -package fsnotify - -import ( - "fmt" - "os" - "path/filepath" - "syscall" - "testing" - "time" -) - -func TestInotifyCloseRightAway(t *testing.T) { - w, err := NewWatcher() - if err != nil { - t.Fatalf("Failed to create watcher") - } - - // Close immediately; it won't even reach the first syscall.Read. - w.Close() - - // Wait for the close to complete. - <-time.After(50 * time.Millisecond) - isWatcherReallyClosed(t, w) -} - -func TestInotifyCloseSlightlyLater(t *testing.T) { - w, err := NewWatcher() - if err != nil { - t.Fatalf("Failed to create watcher") - } - - // Wait until readEvents has reached syscall.Read, and Close. - <-time.After(50 * time.Millisecond) - w.Close() - - // Wait for the close to complete. - <-time.After(50 * time.Millisecond) - isWatcherReallyClosed(t, w) -} - -func TestInotifyCloseSlightlyLaterWithWatch(t *testing.T) { - testDir := tempMkdir(t) - defer os.RemoveAll(testDir) - - w, err := NewWatcher() - if err != nil { - t.Fatalf("Failed to create watcher") - } - w.Add(testDir) - - // Wait until readEvents has reached syscall.Read, and Close. - <-time.After(50 * time.Millisecond) - w.Close() - - // Wait for the close to complete. - <-time.After(50 * time.Millisecond) - isWatcherReallyClosed(t, w) -} - -func TestInotifyCloseAfterRead(t *testing.T) { - testDir := tempMkdir(t) - defer os.RemoveAll(testDir) - - w, err := NewWatcher() - if err != nil { - t.Fatalf("Failed to create watcher") - } - - err = w.Add(testDir) - if err != nil { - t.Fatalf("Failed to add .") - } - - // Generate an event. - os.Create(filepath.Join(testDir, "somethingSOMETHINGsomethingSOMETHING")) - - // Wait for readEvents to read the event, then close the watcher. - <-time.After(50 * time.Millisecond) - w.Close() - - // Wait for the close to complete. - <-time.After(50 * time.Millisecond) - isWatcherReallyClosed(t, w) -} - -func isWatcherReallyClosed(t *testing.T, w *Watcher) { - select { - case err, ok := <-w.Errors: - if ok { - t.Fatalf("w.Errors is not closed; readEvents is still alive after closing (error: %v)", err) - } - default: - t.Fatalf("w.Errors would have blocked; readEvents is still alive!") - } - - select { - case _, ok := <-w.Events: - if ok { - t.Fatalf("w.Events is not closed; readEvents is still alive after closing") - } - default: - t.Fatalf("w.Events would have blocked; readEvents is still alive!") - } -} - -func TestInotifyCloseCreate(t *testing.T) { - testDir := tempMkdir(t) - defer os.RemoveAll(testDir) - - w, err := NewWatcher() - if err != nil { - t.Fatalf("Failed to create watcher: %v", err) - } - defer w.Close() - - err = w.Add(testDir) - if err != nil { - t.Fatalf("Failed to add testDir: %v", err) - } - h, err := os.Create(filepath.Join(testDir, "testfile")) - if err != nil { - t.Fatalf("Failed to create file in testdir: %v", err) - } - h.Close() - select { - case _ = <-w.Events: - case err := <-w.Errors: - t.Fatalf("Error from watcher: %v", err) - case <-time.After(50 * time.Millisecond): - t.Fatalf("Took too long to wait for event") - } - - // At this point, we've received one event, so the goroutine is ready. - // It's also blocking on syscall.Read. - // Now we try to swap the file descriptor under its nose. - w.Close() - w, err = NewWatcher() - defer w.Close() - if err != nil { - t.Fatalf("Failed to create second watcher: %v", err) - } - - <-time.After(50 * time.Millisecond) - err = w.Add(testDir) - if err != nil { - t.Fatalf("Error adding testDir again: %v", err) - } -} - -func TestInotifyStress(t *testing.T) { - testDir := tempMkdir(t) - defer os.RemoveAll(testDir) - testFile := filepath.Join(testDir, "testfile") - - w, err := NewWatcher() - if err != nil { - t.Fatalf("Failed to create watcher: %v", err) - } - defer w.Close() - - killchan := make(chan struct{}) - defer close(killchan) - - err = w.Add(testDir) - if err != nil { - t.Fatalf("Failed to add testDir: %v", err) - } - - proc, err := os.FindProcess(os.Getpid()) - if err != nil { - t.Fatalf("Error finding process: %v", err) - } - - go func() { - for { - select { - case <-time.After(5 * time.Millisecond): - err := proc.Signal(syscall.SIGUSR1) - if err != nil { - t.Fatalf("Signal failed: %v", err) - } - case <-killchan: - return - } - } - }() - - go func() { - for { - select { - case <-time.After(11 * time.Millisecond): - err := w.poller.wake() - if err != nil { - t.Fatalf("Wake failed: %v", err) - } - case <-killchan: - return - } - } - }() - - go func() { - for { - select { - case <-killchan: - return - default: - handle, err := os.Create(testFile) - if err != nil { - t.Fatalf("Create failed: %v", err) - } - handle.Close() - time.Sleep(time.Millisecond) - err = os.Remove(testFile) - if err != nil { - t.Fatalf("Remove failed: %v", err) - } - } - } - }() - - creates := 0 - removes := 0 - after := time.After(5 * time.Second) - for { - select { - case <-after: - if creates-removes > 1 || creates-removes < -1 { - t.Fatalf("Creates and removes should not be off by more than one: %d creates, %d removes", creates, removes) - } - if creates < 50 { - t.Fatalf("Expected at least 50 creates, got %d", creates) - } - return - case err := <-w.Errors: - t.Fatalf("Got an error from watcher: %v", err) - case evt := <-w.Events: - if evt.Name != testFile { - t.Fatalf("Got an event for an unknown file: %s", evt.Name) - } - if evt.Op == Create { - creates++ - } - if evt.Op == Remove { - removes++ - } - } - } -} - -func TestInotifyRemoveTwice(t *testing.T) { - testDir := tempMkdir(t) - defer os.RemoveAll(testDir) - testFile := filepath.Join(testDir, "testfile") - - handle, err := os.Create(testFile) - if err != nil { - t.Fatalf("Create failed: %v", err) - } - handle.Close() - - w, err := NewWatcher() - if err != nil { - t.Fatalf("Failed to create watcher: %v", err) - } - defer w.Close() - - err = w.Add(testFile) - if err != nil { - t.Fatalf("Failed to add testFile: %v", err) - } - - err = os.Remove(testFile) - if err != nil { - t.Fatalf("Failed to remove testFile: %v", err) - } - - err = w.Remove(testFile) - if err == nil { - t.Fatalf("no error on removing invalid file") - } - s1 := fmt.Sprintf("%s", err) - - err = w.Remove(testFile) - if err == nil { - t.Fatalf("no error on removing invalid file") - } - s2 := fmt.Sprintf("%s", err) - - if s1 != s2 { - t.Fatalf("receive different error - %s / %s", s1, s2) - } -} - -func TestInotifyInnerMapLength(t *testing.T) { - testDir := tempMkdir(t) - defer os.RemoveAll(testDir) - testFile := filepath.Join(testDir, "testfile") - - handle, err := os.Create(testFile) - if err != nil { - t.Fatalf("Create failed: %v", err) - } - handle.Close() - - w, err := NewWatcher() - if err != nil { - t.Fatalf("Failed to create watcher: %v", err) - } - defer w.Close() - - err = w.Add(testFile) - if err != nil { - t.Fatalf("Failed to add testFile: %v", err) - } - go func() { - for err := range w.Errors { - t.Fatalf("error received: %s", err) - } - }() - - err = os.Remove(testFile) - if err != nil { - t.Fatalf("Failed to remove testFile: %v", err) - } - _ = <-w.Events // consume Remove event - <-time.After(50 * time.Millisecond) // wait IN_IGNORE propagated - - if len(w.watches) != 0 { - t.Fatalf("Expected watches len is 0, but got: %d, %v", len(w.watches), w.watches) - } - if len(w.paths) != 0 { - t.Fatalf("Expected paths len is 0, but got: %d, %v", len(w.paths), w.paths) - } -} diff --git a/Godeps/_workspace/src/gopkg.in/fsnotify.v1/integration_test.go b/Godeps/_workspace/src/gopkg.in/fsnotify.v1/integration_test.go deleted file mode 100644 index 49e48ff1c..000000000 --- a/Godeps/_workspace/src/gopkg.in/fsnotify.v1/integration_test.go +++ /dev/null @@ -1,1183 +0,0 @@ -// Copyright 2010 The Go Authors. All rights reserved. -// Use of this source code is governed by a BSD-style -// license that can be found in the LICENSE file. - -// +build !plan9,!solaris - -package fsnotify - -import ( - "io/ioutil" - "os" - "os/exec" - "path" - "path/filepath" - "runtime" - "sync/atomic" - "testing" - "time" -) - -// An atomic counter -type counter struct { - val int32 -} - -func (c *counter) increment() { - atomic.AddInt32(&c.val, 1) -} - -func (c *counter) value() int32 { - return atomic.LoadInt32(&c.val) -} - -func (c *counter) reset() { - atomic.StoreInt32(&c.val, 0) -} - -// tempMkdir makes a temporary directory -func tempMkdir(t *testing.T) string { - dir, err := ioutil.TempDir("", "fsnotify") - if err != nil { - t.Fatalf("failed to create test directory: %s", err) - } - return dir -} - -// newWatcher initializes an fsnotify Watcher instance. -func newWatcher(t *testing.T) *Watcher { - watcher, err := NewWatcher() - if err != nil { - t.Fatalf("NewWatcher() failed: %s", err) - } - return watcher -} - -// addWatch adds a watch for a directory -func addWatch(t *testing.T, watcher *Watcher, dir string) { - if err := watcher.Add(dir); err != nil { - t.Fatalf("watcher.Add(%q) failed: %s", dir, err) - } -} - -func TestFsnotifyMultipleOperations(t *testing.T) { - watcher := newWatcher(t) - - // Receive errors on the error channel on a separate goroutine - go func() { - for err := range watcher.Errors { - t.Fatalf("error received: %s", err) - } - }() - - // Create directory to watch - testDir := tempMkdir(t) - defer os.RemoveAll(testDir) - - // Create directory that's not watched - testDirToMoveFiles := tempMkdir(t) - defer os.RemoveAll(testDirToMoveFiles) - - testFile := filepath.Join(testDir, "TestFsnotifySeq.testfile") - testFileRenamed := filepath.Join(testDirToMoveFiles, "TestFsnotifySeqRename.testfile") - - addWatch(t, watcher, testDir) - - // Receive events on the event channel on a separate goroutine - eventstream := watcher.Events - var createReceived, modifyReceived, deleteReceived, renameReceived counter - done := make(chan bool) - go func() { - for event := range eventstream { - // Only count relevant events - if event.Name == filepath.Clean(testDir) || event.Name == filepath.Clean(testFile) { - t.Logf("event received: %s", event) - if event.Op&Remove == Remove { - deleteReceived.increment() - } - if event.Op&Write == Write { - modifyReceived.increment() - } - if event.Op&Create == Create { - createReceived.increment() - } - if event.Op&Rename == Rename { - renameReceived.increment() - } - } else { - t.Logf("unexpected event received: %s", event) - } - } - done <- true - }() - - // Create a file - // This should add at least one event to the fsnotify event queue - var f *os.File - f, err := os.OpenFile(testFile, os.O_WRONLY|os.O_CREATE, 0666) - if err != nil { - t.Fatalf("creating test file failed: %s", err) - } - f.Sync() - - time.Sleep(time.Millisecond) - f.WriteString("data") - f.Sync() - f.Close() - - time.Sleep(50 * time.Millisecond) // give system time to sync write change before delete - - if err := testRename(testFile, testFileRenamed); err != nil { - t.Fatalf("rename failed: %s", err) - } - - // Modify the file outside of the watched dir - f, err = os.Open(testFileRenamed) - if err != nil { - t.Fatalf("open test renamed file failed: %s", err) - } - f.WriteString("data") - f.Sync() - f.Close() - - time.Sleep(50 * time.Millisecond) // give system time to sync write change before delete - - // Recreate the file that was moved - f, err = os.OpenFile(testFile, os.O_WRONLY|os.O_CREATE, 0666) - if err != nil { - t.Fatalf("creating test file failed: %s", err) - } - f.Close() - time.Sleep(50 * time.Millisecond) // give system time to sync write change before delete - - // We expect this event to be received almost immediately, but let's wait 500 ms to be sure - time.Sleep(500 * time.Millisecond) - cReceived := createReceived.value() - if cReceived != 2 { - t.Fatalf("incorrect number of create events received after 500 ms (%d vs %d)", cReceived, 2) - } - mReceived := modifyReceived.value() - if mReceived != 1 { - t.Fatalf("incorrect number of modify events received after 500 ms (%d vs %d)", mReceived, 1) - } - dReceived := deleteReceived.value() - rReceived := renameReceived.value() - if dReceived+rReceived != 1 { - t.Fatalf("incorrect number of rename+delete events received after 500 ms (%d vs %d)", rReceived+dReceived, 1) - } - - // Try closing the fsnotify instance - t.Log("calling Close()") - watcher.Close() - t.Log("waiting for the event channel to become closed...") - select { - case <-done: - t.Log("event channel closed") - case <-time.After(2 * time.Second): - t.Fatal("event stream was not closed after 2 seconds") - } -} - -func TestFsnotifyMultipleCreates(t *testing.T) { - watcher := newWatcher(t) - - // Receive errors on the error channel on a separate goroutine - go func() { - for err := range watcher.Errors { - t.Fatalf("error received: %s", err) - } - }() - - // Create directory to watch - testDir := tempMkdir(t) - defer os.RemoveAll(testDir) - - testFile := filepath.Join(testDir, "TestFsnotifySeq.testfile") - - addWatch(t, watcher, testDir) - - // Receive events on the event channel on a separate goroutine - eventstream := watcher.Events - var createReceived, modifyReceived, deleteReceived counter - done := make(chan bool) - go func() { - for event := range eventstream { - // Only count relevant events - if event.Name == filepath.Clean(testDir) || event.Name == filepath.Clean(testFile) { - t.Logf("event received: %s", event) - if event.Op&Remove == Remove { - deleteReceived.increment() - } - if event.Op&Create == Create { - createReceived.increment() - } - if event.Op&Write == Write { - modifyReceived.increment() - } - } else { - t.Logf("unexpected event received: %s", event) - } - } - done <- true - }() - - // Create a file - // This should add at least one event to the fsnotify event queue - var f *os.File - f, err := os.OpenFile(testFile, os.O_WRONLY|os.O_CREATE, 0666) - if err != nil { - t.Fatalf("creating test file failed: %s", err) - } - f.Sync() - - time.Sleep(time.Millisecond) - f.WriteString("data") - f.Sync() - f.Close() - - time.Sleep(50 * time.Millisecond) // give system time to sync write change before delete - - os.Remove(testFile) - - time.Sleep(50 * time.Millisecond) // give system time to sync write change before delete - - // Recreate the file - f, err = os.OpenFile(testFile, os.O_WRONLY|os.O_CREATE, 0666) - if err != nil { - t.Fatalf("creating test file failed: %s", err) - } - f.Close() - time.Sleep(50 * time.Millisecond) // give system time to sync write change before delete - - // Modify - f, err = os.OpenFile(testFile, os.O_WRONLY, 0666) - if err != nil { - t.Fatalf("creating test file failed: %s", err) - } - f.Sync() - - time.Sleep(time.Millisecond) - f.WriteString("data") - f.Sync() - f.Close() - - time.Sleep(50 * time.Millisecond) // give system time to sync write change before delete - - // Modify - f, err = os.OpenFile(testFile, os.O_WRONLY, 0666) - if err != nil { - t.Fatalf("creating test file failed: %s", err) - } - f.Sync() - - time.Sleep(time.Millisecond) - f.WriteString("data") - f.Sync() - f.Close() - - time.Sleep(50 * time.Millisecond) // give system time to sync write change before delete - - // We expect this event to be received almost immediately, but let's wait 500 ms to be sure - time.Sleep(500 * time.Millisecond) - cReceived := createReceived.value() - if cReceived != 2 { - t.Fatalf("incorrect number of create events received after 500 ms (%d vs %d)", cReceived, 2) - } - mReceived := modifyReceived.value() - if mReceived < 3 { - t.Fatalf("incorrect number of modify events received after 500 ms (%d vs atleast %d)", mReceived, 3) - } - dReceived := deleteReceived.value() - if dReceived != 1 { - t.Fatalf("incorrect number of rename+delete events received after 500 ms (%d vs %d)", dReceived, 1) - } - - // Try closing the fsnotify instance - t.Log("calling Close()") - watcher.Close() - t.Log("waiting for the event channel to become closed...") - select { - case <-done: - t.Log("event channel closed") - case <-time.After(2 * time.Second): - t.Fatal("event stream was not closed after 2 seconds") - } -} - -func TestFsnotifyDirOnly(t *testing.T) { - watcher := newWatcher(t) - - // Create directory to watch - testDir := tempMkdir(t) - defer os.RemoveAll(testDir) - - // Create a file before watching directory - // This should NOT add any events to the fsnotify event queue - testFileAlreadyExists := filepath.Join(testDir, "TestFsnotifyEventsExisting.testfile") - { - var f *os.File - f, err := os.OpenFile(testFileAlreadyExists, os.O_WRONLY|os.O_CREATE, 0666) - if err != nil { - t.Fatalf("creating test file failed: %s", err) - } - f.Sync() - f.Close() - } - - addWatch(t, watcher, testDir) - - // Receive errors on the error channel on a separate goroutine - go func() { - for err := range watcher.Errors { - t.Fatalf("error received: %s", err) - } - }() - - testFile := filepath.Join(testDir, "TestFsnotifyDirOnly.testfile") - - // Receive events on the event channel on a separate goroutine - eventstream := watcher.Events - var createReceived, modifyReceived, deleteReceived counter - done := make(chan bool) - go func() { - for event := range eventstream { - // Only count relevant events - if event.Name == filepath.Clean(testDir) || event.Name == filepath.Clean(testFile) || event.Name == filepath.Clean(testFileAlreadyExists) { - t.Logf("event received: %s", event) - if event.Op&Remove == Remove { - deleteReceived.increment() - } - if event.Op&Write == Write { - modifyReceived.increment() - } - if event.Op&Create == Create { - createReceived.increment() - } - } else { - t.Logf("unexpected event received: %s", event) - } - } - done <- true - }() - - // Create a file - // This should add at least one event to the fsnotify event queue - var f *os.File - f, err := os.OpenFile(testFile, os.O_WRONLY|os.O_CREATE, 0666) - if err != nil { - t.Fatalf("creating test file failed: %s", err) - } - f.Sync() - - time.Sleep(time.Millisecond) - f.WriteString("data") - f.Sync() - f.Close() - - time.Sleep(50 * time.Millisecond) // give system time to sync write change before delete - - os.Remove(testFile) - os.Remove(testFileAlreadyExists) - - // We expect this event to be received almost immediately, but let's wait 500 ms to be sure - time.Sleep(500 * time.Millisecond) - cReceived := createReceived.value() - if cReceived != 1 { - t.Fatalf("incorrect number of create events received after 500 ms (%d vs %d)", cReceived, 1) - } - mReceived := modifyReceived.value() - if mReceived != 1 { - t.Fatalf("incorrect number of modify events received after 500 ms (%d vs %d)", mReceived, 1) - } - dReceived := deleteReceived.value() - if dReceived != 2 { - t.Fatalf("incorrect number of delete events received after 500 ms (%d vs %d)", dReceived, 2) - } - - // Try closing the fsnotify instance - t.Log("calling Close()") - watcher.Close() - t.Log("waiting for the event channel to become closed...") - select { - case <-done: - t.Log("event channel closed") - case <-time.After(2 * time.Second): - t.Fatal("event stream was not closed after 2 seconds") - } -} - -func TestFsnotifyDeleteWatchedDir(t *testing.T) { - watcher := newWatcher(t) - defer watcher.Close() - - // Create directory to watch - testDir := tempMkdir(t) - defer os.RemoveAll(testDir) - - // Create a file before watching directory - testFileAlreadyExists := filepath.Join(testDir, "TestFsnotifyEventsExisting.testfile") - { - var f *os.File - f, err := os.OpenFile(testFileAlreadyExists, os.O_WRONLY|os.O_CREATE, 0666) - if err != nil { - t.Fatalf("creating test file failed: %s", err) - } - f.Sync() - f.Close() - } - - addWatch(t, watcher, testDir) - - // Add a watch for testFile - addWatch(t, watcher, testFileAlreadyExists) - - // Receive errors on the error channel on a separate goroutine - go func() { - for err := range watcher.Errors { - t.Fatalf("error received: %s", err) - } - }() - - // Receive events on the event channel on a separate goroutine - eventstream := watcher.Events - var deleteReceived counter - go func() { - for event := range eventstream { - // Only count relevant events - if event.Name == filepath.Clean(testDir) || event.Name == filepath.Clean(testFileAlreadyExists) { - t.Logf("event received: %s", event) - if event.Op&Remove == Remove { - deleteReceived.increment() - } - } else { - t.Logf("unexpected event received: %s", event) - } - } - }() - - os.RemoveAll(testDir) - - // We expect this event to be received almost immediately, but let's wait 500 ms to be sure - time.Sleep(500 * time.Millisecond) - dReceived := deleteReceived.value() - if dReceived < 2 { - t.Fatalf("did not receive at least %d delete events, received %d after 500 ms", 2, dReceived) - } -} - -func TestFsnotifySubDir(t *testing.T) { - watcher := newWatcher(t) - - // Create directory to watch - testDir := tempMkdir(t) - defer os.RemoveAll(testDir) - - testFile1 := filepath.Join(testDir, "TestFsnotifyFile1.testfile") - testSubDir := filepath.Join(testDir, "sub") - testSubDirFile := filepath.Join(testDir, "sub/TestFsnotifyFile1.testfile") - - // Receive errors on the error channel on a separate goroutine - go func() { - for err := range watcher.Errors { - t.Fatalf("error received: %s", err) - } - }() - - // Receive events on the event channel on a separate goroutine - eventstream := watcher.Events - var createReceived, deleteReceived counter - done := make(chan bool) - go func() { - for event := range eventstream { - // Only count relevant events - if event.Name == filepath.Clean(testDir) || event.Name == filepath.Clean(testSubDir) || event.Name == filepath.Clean(testFile1) { - t.Logf("event received: %s", event) - if event.Op&Create == Create { - createReceived.increment() - } - if event.Op&Remove == Remove { - deleteReceived.increment() - } - } else { - t.Logf("unexpected event received: %s", event) - } - } - done <- true - }() - - addWatch(t, watcher, testDir) - - // Create sub-directory - if err := os.Mkdir(testSubDir, 0777); err != nil { - t.Fatalf("failed to create test sub-directory: %s", err) - } - - // Create a file - var f *os.File - f, err := os.OpenFile(testFile1, os.O_WRONLY|os.O_CREATE, 0666) - if err != nil { - t.Fatalf("creating test file failed: %s", err) - } - f.Sync() - f.Close() - - // Create a file (Should not see this! we are not watching subdir) - var fs *os.File - fs, err = os.OpenFile(testSubDirFile, os.O_WRONLY|os.O_CREATE, 0666) - if err != nil { - t.Fatalf("creating test file failed: %s", err) - } - fs.Sync() - fs.Close() - - time.Sleep(200 * time.Millisecond) - - // Make sure receive deletes for both file and sub-directory - os.RemoveAll(testSubDir) - os.Remove(testFile1) - - // We expect this event to be received almost immediately, but let's wait 500 ms to be sure - time.Sleep(500 * time.Millisecond) - cReceived := createReceived.value() - if cReceived != 2 { - t.Fatalf("incorrect number of create events received after 500 ms (%d vs %d)", cReceived, 2) - } - dReceived := deleteReceived.value() - if dReceived != 2 { - t.Fatalf("incorrect number of delete events received after 500 ms (%d vs %d)", dReceived, 2) - } - - // Try closing the fsnotify instance - t.Log("calling Close()") - watcher.Close() - t.Log("waiting for the event channel to become closed...") - select { - case <-done: - t.Log("event channel closed") - case <-time.After(2 * time.Second): - t.Fatal("event stream was not closed after 2 seconds") - } -} - -func TestFsnotifyRename(t *testing.T) { - watcher := newWatcher(t) - - // Create directory to watch - testDir := tempMkdir(t) - defer os.RemoveAll(testDir) - - addWatch(t, watcher, testDir) - - // Receive errors on the error channel on a separate goroutine - go func() { - for err := range watcher.Errors { - t.Fatalf("error received: %s", err) - } - }() - - testFile := filepath.Join(testDir, "TestFsnotifyEvents.testfile") - testFileRenamed := filepath.Join(testDir, "TestFsnotifyEvents.testfileRenamed") - - // Receive events on the event channel on a separate goroutine - eventstream := watcher.Events - var renameReceived counter - done := make(chan bool) - go func() { - for event := range eventstream { - // Only count relevant events - if event.Name == filepath.Clean(testDir) || event.Name == filepath.Clean(testFile) || event.Name == filepath.Clean(testFileRenamed) { - if event.Op&Rename == Rename { - renameReceived.increment() - } - t.Logf("event received: %s", event) - } else { - t.Logf("unexpected event received: %s", event) - } - } - done <- true - }() - - // Create a file - // This should add at least one event to the fsnotify event queue - var f *os.File - f, err := os.OpenFile(testFile, os.O_WRONLY|os.O_CREATE, 0666) - if err != nil { - t.Fatalf("creating test file failed: %s", err) - } - f.Sync() - - f.WriteString("data") - f.Sync() - f.Close() - - // Add a watch for testFile - addWatch(t, watcher, testFile) - - if err := testRename(testFile, testFileRenamed); err != nil { - t.Fatalf("rename failed: %s", err) - } - - // We expect this event to be received almost immediately, but let's wait 500 ms to be sure - time.Sleep(500 * time.Millisecond) - if renameReceived.value() == 0 { - t.Fatal("fsnotify rename events have not been received after 500 ms") - } - - // Try closing the fsnotify instance - t.Log("calling Close()") - watcher.Close() - t.Log("waiting for the event channel to become closed...") - select { - case <-done: - t.Log("event channel closed") - case <-time.After(2 * time.Second): - t.Fatal("event stream was not closed after 2 seconds") - } - - os.Remove(testFileRenamed) -} - -func TestFsnotifyRenameToCreate(t *testing.T) { - watcher := newWatcher(t) - - // Create directory to watch - testDir := tempMkdir(t) - defer os.RemoveAll(testDir) - - // Create directory to get file - testDirFrom := tempMkdir(t) - defer os.RemoveAll(testDirFrom) - - addWatch(t, watcher, testDir) - - // Receive errors on the error channel on a separate goroutine - go func() { - for err := range watcher.Errors { - t.Fatalf("error received: %s", err) - } - }() - - testFile := filepath.Join(testDirFrom, "TestFsnotifyEvents.testfile") - testFileRenamed := filepath.Join(testDir, "TestFsnotifyEvents.testfileRenamed") - - // Receive events on the event channel on a separate goroutine - eventstream := watcher.Events - var createReceived counter - done := make(chan bool) - go func() { - for event := range eventstream { - // Only count relevant events - if event.Name == filepath.Clean(testDir) || event.Name == filepath.Clean(testFile) || event.Name == filepath.Clean(testFileRenamed) { - if event.Op&Create == Create { - createReceived.increment() - } - t.Logf("event received: %s", event) - } else { - t.Logf("unexpected event received: %s", event) - } - } - done <- true - }() - - // Create a file - // This should add at least one event to the fsnotify event queue - var f *os.File - f, err := os.OpenFile(testFile, os.O_WRONLY|os.O_CREATE, 0666) - if err != nil { - t.Fatalf("creating test file failed: %s", err) - } - f.Sync() - f.Close() - - if err := testRename(testFile, testFileRenamed); err != nil { - t.Fatalf("rename failed: %s", err) - } - - // We expect this event to be received almost immediately, but let's wait 500 ms to be sure - time.Sleep(500 * time.Millisecond) - if createReceived.value() == 0 { - t.Fatal("fsnotify create events have not been received after 500 ms") - } - - // Try closing the fsnotify instance - t.Log("calling Close()") - watcher.Close() - t.Log("waiting for the event channel to become closed...") - select { - case <-done: - t.Log("event channel closed") - case <-time.After(2 * time.Second): - t.Fatal("event stream was not closed after 2 seconds") - } - - os.Remove(testFileRenamed) -} - -func TestFsnotifyRenameToOverwrite(t *testing.T) { - switch runtime.GOOS { - case "plan9", "windows": - t.Skipf("skipping test on %q (os.Rename over existing file does not create event).", runtime.GOOS) - } - - watcher := newWatcher(t) - - // Create directory to watch - testDir := tempMkdir(t) - defer os.RemoveAll(testDir) - - // Create directory to get file - testDirFrom := tempMkdir(t) - defer os.RemoveAll(testDirFrom) - - testFile := filepath.Join(testDirFrom, "TestFsnotifyEvents.testfile") - testFileRenamed := filepath.Join(testDir, "TestFsnotifyEvents.testfileRenamed") - - // Create a file - var fr *os.File - fr, err := os.OpenFile(testFileRenamed, os.O_WRONLY|os.O_CREATE, 0666) - if err != nil { - t.Fatalf("creating test file failed: %s", err) - } - fr.Sync() - fr.Close() - - addWatch(t, watcher, testDir) - - // Receive errors on the error channel on a separate goroutine - go func() { - for err := range watcher.Errors { - t.Fatalf("error received: %s", err) - } - }() - - // Receive events on the event channel on a separate goroutine - eventstream := watcher.Events - var eventReceived counter - done := make(chan bool) - go func() { - for event := range eventstream { - // Only count relevant events - if event.Name == filepath.Clean(testFileRenamed) { - eventReceived.increment() - t.Logf("event received: %s", event) - } else { - t.Logf("unexpected event received: %s", event) - } - } - done <- true - }() - - // Create a file - // This should add at least one event to the fsnotify event queue - var f *os.File - f, err = os.OpenFile(testFile, os.O_WRONLY|os.O_CREATE, 0666) - if err != nil { - t.Fatalf("creating test file failed: %s", err) - } - f.Sync() - f.Close() - - if err := testRename(testFile, testFileRenamed); err != nil { - t.Fatalf("rename failed: %s", err) - } - - // We expect this event to be received almost immediately, but let's wait 500 ms to be sure - time.Sleep(500 * time.Millisecond) - if eventReceived.value() == 0 { - t.Fatal("fsnotify events have not been received after 500 ms") - } - - // Try closing the fsnotify instance - t.Log("calling Close()") - watcher.Close() - t.Log("waiting for the event channel to become closed...") - select { - case <-done: - t.Log("event channel closed") - case <-time.After(2 * time.Second): - t.Fatal("event stream was not closed after 2 seconds") - } - - os.Remove(testFileRenamed) -} - -func TestRemovalOfWatch(t *testing.T) { - // Create directory to watch - testDir := tempMkdir(t) - defer os.RemoveAll(testDir) - - // Create a file before watching directory - testFileAlreadyExists := filepath.Join(testDir, "TestFsnotifyEventsExisting.testfile") - { - var f *os.File - f, err := os.OpenFile(testFileAlreadyExists, os.O_WRONLY|os.O_CREATE, 0666) - if err != nil { - t.Fatalf("creating test file failed: %s", err) - } - f.Sync() - f.Close() - } - - watcher := newWatcher(t) - defer watcher.Close() - - addWatch(t, watcher, testDir) - if err := watcher.Remove(testDir); err != nil { - t.Fatalf("Could not remove the watch: %v\n", err) - } - - go func() { - select { - case ev := <-watcher.Events: - t.Fatalf("We received event: %v\n", ev) - case <-time.After(500 * time.Millisecond): - t.Log("No event received, as expected.") - } - }() - - time.Sleep(200 * time.Millisecond) - // Modify the file outside of the watched dir - f, err := os.Open(testFileAlreadyExists) - if err != nil { - t.Fatalf("Open test file failed: %s", err) - } - f.WriteString("data") - f.Sync() - f.Close() - if err := os.Chmod(testFileAlreadyExists, 0700); err != nil { - t.Fatalf("chmod failed: %s", err) - } - time.Sleep(400 * time.Millisecond) -} - -func TestFsnotifyAttrib(t *testing.T) { - if runtime.GOOS == "windows" { - t.Skip("attributes don't work on Windows.") - } - - watcher := newWatcher(t) - - // Create directory to watch - testDir := tempMkdir(t) - defer os.RemoveAll(testDir) - - // Receive errors on the error channel on a separate goroutine - go func() { - for err := range watcher.Errors { - t.Fatalf("error received: %s", err) - } - }() - - testFile := filepath.Join(testDir, "TestFsnotifyAttrib.testfile") - - // Receive events on the event channel on a separate goroutine - eventstream := watcher.Events - // The modifyReceived counter counts IsModify events that are not IsAttrib, - // and the attribReceived counts IsAttrib events (which are also IsModify as - // a consequence). - var modifyReceived counter - var attribReceived counter - done := make(chan bool) - go func() { - for event := range eventstream { - // Only count relevant events - if event.Name == filepath.Clean(testDir) || event.Name == filepath.Clean(testFile) { - if event.Op&Write == Write { - modifyReceived.increment() - } - if event.Op&Chmod == Chmod { - attribReceived.increment() - } - t.Logf("event received: %s", event) - } else { - t.Logf("unexpected event received: %s", event) - } - } - done <- true - }() - - // Create a file - // This should add at least one event to the fsnotify event queue - var f *os.File - f, err := os.OpenFile(testFile, os.O_WRONLY|os.O_CREATE, 0666) - if err != nil { - t.Fatalf("creating test file failed: %s", err) - } - f.Sync() - - f.WriteString("data") - f.Sync() - f.Close() - - // Add a watch for testFile - addWatch(t, watcher, testFile) - - if err := os.Chmod(testFile, 0700); err != nil { - t.Fatalf("chmod failed: %s", err) - } - - // We expect this event to be received almost immediately, but let's wait 500 ms to be sure - // Creating/writing a file changes also the mtime, so IsAttrib should be set to true here - time.Sleep(500 * time.Millisecond) - if modifyReceived.value() != 0 { - t.Fatal("received an unexpected modify event when creating a test file") - } - if attribReceived.value() == 0 { - t.Fatal("fsnotify attribute events have not received after 500 ms") - } - - // Modifying the contents of the file does not set the attrib flag (although eg. the mtime - // might have been modified). - modifyReceived.reset() - attribReceived.reset() - - f, err = os.OpenFile(testFile, os.O_WRONLY, 0) - if err != nil { - t.Fatalf("reopening test file failed: %s", err) - } - - f.WriteString("more data") - f.Sync() - f.Close() - - time.Sleep(500 * time.Millisecond) - - if modifyReceived.value() != 1 { - t.Fatal("didn't receive a modify event after changing test file contents") - } - - if attribReceived.value() != 0 { - t.Fatal("did receive an unexpected attrib event after changing test file contents") - } - - modifyReceived.reset() - attribReceived.reset() - - // Doing a chmod on the file should trigger an event with the "attrib" flag set (the contents - // of the file are not changed though) - if err := os.Chmod(testFile, 0600); err != nil { - t.Fatalf("chmod failed: %s", err) - } - - time.Sleep(500 * time.Millisecond) - - if attribReceived.value() != 1 { - t.Fatal("didn't receive an attribute change after 500ms") - } - - // Try closing the fsnotify instance - t.Log("calling Close()") - watcher.Close() - t.Log("waiting for the event channel to become closed...") - select { - case <-done: - t.Log("event channel closed") - case <-time.After(1e9): - t.Fatal("event stream was not closed after 1 second") - } - - os.Remove(testFile) -} - -func TestFsnotifyClose(t *testing.T) { - watcher := newWatcher(t) - watcher.Close() - - var done int32 - go func() { - watcher.Close() - atomic.StoreInt32(&done, 1) - }() - - time.Sleep(50e6) // 50 ms - if atomic.LoadInt32(&done) == 0 { - t.Fatal("double Close() test failed: second Close() call didn't return") - } - - testDir := tempMkdir(t) - defer os.RemoveAll(testDir) - - if err := watcher.Add(testDir); err == nil { - t.Fatal("expected error on Watch() after Close(), got nil") - } -} - -func TestFsnotifyFakeSymlink(t *testing.T) { - if runtime.GOOS == "windows" { - t.Skip("symlinks don't work on Windows.") - } - - watcher := newWatcher(t) - - // Create directory to watch - testDir := tempMkdir(t) - defer os.RemoveAll(testDir) - - var errorsReceived counter - // Receive errors on the error channel on a separate goroutine - go func() { - for errors := range watcher.Errors { - t.Logf("Received error: %s", errors) - errorsReceived.increment() - } - }() - - // Count the CREATE events received - var createEventsReceived, otherEventsReceived counter - go func() { - for ev := range watcher.Events { - t.Logf("event received: %s", ev) - if ev.Op&Create == Create { - createEventsReceived.increment() - } else { - otherEventsReceived.increment() - } - } - }() - - addWatch(t, watcher, testDir) - - if err := os.Symlink(filepath.Join(testDir, "zzz"), filepath.Join(testDir, "zzznew")); err != nil { - t.Fatalf("Failed to create bogus symlink: %s", err) - } - t.Logf("Created bogus symlink") - - // We expect this event to be received almost immediately, but let's wait 500 ms to be sure - time.Sleep(500 * time.Millisecond) - - // Should not be error, just no events for broken links (watching nothing) - if errorsReceived.value() > 0 { - t.Fatal("fsnotify errors have been received.") - } - if otherEventsReceived.value() > 0 { - t.Fatal("fsnotify other events received on the broken link") - } - - // Except for 1 create event (for the link itself) - if createEventsReceived.value() == 0 { - t.Fatal("fsnotify create events were not received after 500 ms") - } - if createEventsReceived.value() > 1 { - t.Fatal("fsnotify more create events received than expected") - } - - // Try closing the fsnotify instance - t.Log("calling Close()") - watcher.Close() -} - -func TestCyclicSymlink(t *testing.T) { - if runtime.GOOS == "windows" { - t.Skip("symlinks don't work on Windows.") - } - - watcher := newWatcher(t) - - testDir := tempMkdir(t) - defer os.RemoveAll(testDir) - - link := path.Join(testDir, "link") - if err := os.Symlink(".", link); err != nil { - t.Fatalf("could not make symlink: %v", err) - } - addWatch(t, watcher, testDir) - - var createEventsReceived counter - go func() { - for ev := range watcher.Events { - if ev.Op&Create == Create { - createEventsReceived.increment() - } - } - }() - - if err := os.Remove(link); err != nil { - t.Fatalf("Error removing link: %v", err) - } - - // It would be nice to be able to expect a delete event here, but kqueue has - // no way for us to get events on symlinks themselves, because opening them - // opens an fd to the file to which they point. - - if err := ioutil.WriteFile(link, []byte("foo"), 0700); err != nil { - t.Fatalf("could not make symlink: %v", err) - } - - // We expect this event to be received almost immediately, but let's wait 500 ms to be sure - time.Sleep(500 * time.Millisecond) - - if got := createEventsReceived.value(); got == 0 { - t.Errorf("want at least 1 create event got %v", got) - } - - watcher.Close() -} - -// TestConcurrentRemovalOfWatch tests that concurrent calls to RemoveWatch do not race. -// See https://codereview.appspot.com/103300045/ -// go test -test.run=TestConcurrentRemovalOfWatch -test.cpu=1,1,1,1,1 -race -func TestConcurrentRemovalOfWatch(t *testing.T) { - if runtime.GOOS != "darwin" { - t.Skip("regression test for race only present on darwin") - } - - // Create directory to watch - testDir := tempMkdir(t) - defer os.RemoveAll(testDir) - - // Create a file before watching directory - testFileAlreadyExists := filepath.Join(testDir, "TestFsnotifyEventsExisting.testfile") - { - var f *os.File - f, err := os.OpenFile(testFileAlreadyExists, os.O_WRONLY|os.O_CREATE, 0666) - if err != nil { - t.Fatalf("creating test file failed: %s", err) - } - f.Sync() - f.Close() - } - - watcher := newWatcher(t) - defer watcher.Close() - - addWatch(t, watcher, testDir) - - // Test that RemoveWatch can be invoked concurrently, with no data races. - removed1 := make(chan struct{}) - go func() { - defer close(removed1) - watcher.Remove(testDir) - }() - removed2 := make(chan struct{}) - go func() { - close(removed2) - watcher.Remove(testDir) - }() - <-removed1 - <-removed2 -} - -func TestClose(t *testing.T) { - // Regression test for #59 bad file descriptor from Close - testDir := tempMkdir(t) - defer os.RemoveAll(testDir) - - watcher := newWatcher(t) - if err := watcher.Add(testDir); err != nil { - t.Fatalf("Expected no error on Add, got %v", err) - } - err := watcher.Close() - if err != nil { - t.Fatalf("Expected no error on Close, got %v.", err) - } -} - -func testRename(file1, file2 string) error { - switch runtime.GOOS { - case "windows", "plan9": - return os.Rename(file1, file2) - default: - cmd := exec.Command("mv", file1, file2) - return cmd.Run() - } -} diff --git a/Godeps/_workspace/src/gopkg.in/throttled/throttled.v1/common_test.go b/Godeps/_workspace/src/gopkg.in/throttled/throttled.v1/common_test.go deleted file mode 100644 index ddb57fb1c..000000000 --- a/Godeps/_workspace/src/gopkg.in/throttled/throttled.v1/common_test.go +++ /dev/null @@ -1,65 +0,0 @@ -package throttled - -import ( - "fmt" - "net/http" - "net/http/httptest" - "sync" - "time" - - "github.com/PuerkitoBio/boom/commands" -) - -type stats struct { - sync.Mutex - ok int - dropped int - ts []time.Time - - body func() -} - -func (s *stats) ServeHTTP(w http.ResponseWriter, r *http.Request) { - if s.body != nil { - s.body() - } - s.Lock() - defer s.Unlock() - s.ts = append(s.ts, time.Now()) - s.ok++ - w.WriteHeader(200) -} - -func (s *stats) DeniedHTTP(w http.ResponseWriter, r *http.Request) { - s.Lock() - defer s.Unlock() - s.dropped++ - w.WriteHeader(deniedStatus) -} - -func (s *stats) Stats() (int, int, []time.Time) { - s.Lock() - defer s.Unlock() - return s.ok, s.dropped, s.ts -} - -func runTest(h http.Handler, b ...commands.Boom) []*commands.Report { - srv := httptest.NewServer(h) - defer srv.Close() - - var rpts []*commands.Report - var wg sync.WaitGroup - var mu sync.Mutex - wg.Add(len(b)) - for i, bo := range b { - bo.Req.Url = srv.URL + fmt.Sprintf("/%d", i) - go func(bo commands.Boom) { - mu.Lock() - defer mu.Unlock() - rpts = append(rpts, bo.Run()) - wg.Done() - }(bo) - } - wg.Wait() - return rpts -} diff --git a/Godeps/_workspace/src/gopkg.in/throttled/throttled.v1/delayer_test.go b/Godeps/_workspace/src/gopkg.in/throttled/throttled.v1/delayer_test.go deleted file mode 100644 index 822978e5d..000000000 --- a/Godeps/_workspace/src/gopkg.in/throttled/throttled.v1/delayer_test.go +++ /dev/null @@ -1,65 +0,0 @@ -package throttled - -import ( - "testing" - "time" -) - -func TestDelayer(t *testing.T) { - cases := []struct { - in Delayer - out time.Duration - }{ - 0: {PerSec(1), time.Second}, - 1: {PerSec(2), 500 * time.Millisecond}, - 2: {PerSec(4), 250 * time.Millisecond}, - 3: {PerSec(5), 200 * time.Millisecond}, - 4: {PerSec(10), 100 * time.Millisecond}, - 5: {PerSec(100), 10 * time.Millisecond}, - 6: {PerSec(3), 333333333 * time.Nanosecond}, - 7: {PerMin(1), time.Minute}, - 8: {PerMin(2), 30 * time.Second}, - 9: {PerMin(4), 15 * time.Second}, - 10: {PerMin(5), 12 * time.Second}, - 11: {PerMin(10), 6 * time.Second}, - 12: {PerMin(60), time.Second}, - 13: {PerHour(1), time.Hour}, - 14: {PerHour(2), 30 * time.Minute}, - 15: {PerHour(4), 15 * time.Minute}, - 16: {PerHour(60), time.Minute}, - 17: {PerHour(120), 30 * time.Second}, - 18: {D(time.Second), time.Second}, - 19: {D(5 * time.Minute), 5 * time.Minute}, - 20: {PerSec(200), 5 * time.Millisecond}, - 21: {PerDay(24), time.Hour}, - } - for i, c := range cases { - got := c.in.Delay() - if got != c.out { - t.Errorf("%d: expected %s, got %s", i, c.out, got) - } - } -} - -func TestQuota(t *testing.T) { - cases := []struct { - q Quota - reqs int - win time.Duration - }{ - 0: {PerSec(10), 10, time.Second}, - 1: {PerMin(30), 30, time.Minute}, - 2: {PerHour(124), 124, time.Hour}, - 3: {PerDay(1), 1, 24 * time.Hour}, - 4: {Q{148, 17 * time.Second}, 148, 17 * time.Second}, - } - for i, c := range cases { - r, w := c.q.Quota() - if r != c.reqs { - t.Errorf("%d: expected %d requests, got %d", i, c.reqs, r) - } - if w != c.win { - t.Errorf("%d: expected %s window, got %s", i, c.win, w) - } - } -} diff --git a/Godeps/_workspace/src/gopkg.in/throttled/throttled.v1/interval_test.go b/Godeps/_workspace/src/gopkg.in/throttled/throttled.v1/interval_test.go deleted file mode 100644 index bc584e134..000000000 --- a/Godeps/_workspace/src/gopkg.in/throttled/throttled.v1/interval_test.go +++ /dev/null @@ -1,114 +0,0 @@ -package throttled - -import ( - "net/http" - "testing" - - "github.com/PuerkitoBio/boom/commands" -) - -func TestInterval(t *testing.T) { - if testing.Short() { - t.Skip() - } - cases := []struct { - n int - c int - rps int - bursts int - }{ - 0: {60, 10, 20, 100}, - 1: {300, 20, 100, 100}, - 2: {10, 10, 1, 10}, - 3: {1000, 100, 1000, 100}, - } - for i, c := range cases { - // Setup the stats handler - st := &stats{} - // Create the throttler - th := Interval(PerSec(c.rps), c.bursts, nil, 0) - th.DeniedHandler = http.HandlerFunc(st.DeniedHTTP) - b := commands.Boom{ - Req: &commands.ReqOpts{}, - N: c.n, - C: c.c, - Output: "quiet", - } - // Run the test - rpts := runTest(th.Throttle(st), b) - // Assert results - for _, rpt := range rpts { - assertRPS(t, i, c.rps, rpt) - } - assertStats(t, i, st, rpts) - } -} - -func TestIntervalVary(t *testing.T) { - if testing.Short() { - t.Skip() - } - cases := []struct { - n int - c int - urls int - rps int - bursts int - }{ - 0: {60, 10, 3, 20, 100}, - 1: {300, 20, 3, 100, 100}, - 2: {10, 10, 3, 1, 10}, - 3: {500, 10, 2, 1000, 100}, - } - for i, c := range cases { - // Setup the stats handler - st := &stats{} - // Create the throttler - th := Interval(PerSec(c.rps), c.bursts, nil, 0) - th.DeniedHandler = http.HandlerFunc(st.DeniedHTTP) - var booms []commands.Boom - for j := 0; j < c.urls; j++ { - booms = append(booms, commands.Boom{ - Req: &commands.ReqOpts{}, - N: c.n, - C: c.c, - Output: "quiet", - }) - } - // Run the test - rpts := runTest(th.Throttle(st), booms...) - // Assert results - for _, rpt := range rpts { - assertRPS(t, i, c.rps, rpt) - } - assertStats(t, i, st, rpts) - } -} - -func assertRPS(t *testing.T, ix int, exp int, rpt *commands.Report) { - wigglef := 0.2 * float64(exp) - if rpt.SuccessRPS < float64(exp)-wigglef || rpt.SuccessRPS > float64(exp)+wigglef { - t.Errorf("%d: expected RPS to be around %d, got %f", ix, exp, rpt.SuccessRPS) - } -} - -func assertStats(t *testing.T, ix int, st *stats, rpts []*commands.Report) { - ok, ko, _ := st.Stats() - var twos, fives, max int - for _, rpt := range rpts { - twos += rpt.StatusCodeDist[200] - fives += rpt.StatusCodeDist[deniedStatus] - if len(rpt.StatusCodeDist) > max { - max = len(rpt.StatusCodeDist) - } - } - if ok != twos { - t.Errorf("%d: expected %d status 200, got %d", ix, twos, ok) - } - if ko != fives { - t.Errorf("%d: expected %d status 429, got %d", ix, fives, ok) - } - if max > 2 { - t.Errorf("%d: expected at most 2 different status codes, got %d", ix, max) - } -} diff --git a/Godeps/_workspace/src/gopkg.in/throttled/throttled.v1/memstats_test.go b/Godeps/_workspace/src/gopkg.in/throttled/throttled.v1/memstats_test.go deleted file mode 100644 index 2b8faa721..000000000 --- a/Godeps/_workspace/src/gopkg.in/throttled/throttled.v1/memstats_test.go +++ /dev/null @@ -1,64 +0,0 @@ -package throttled - -import ( - "net/http" - "runtime" - "testing" - "time" - - "github.com/PuerkitoBio/boom/commands" -) - -func TestMemStats(t *testing.T) { - if testing.Short() { - t.Skip() - } - cases := []struct { - n int - c int - gc uint32 - total uint64 - rate time.Duration - }{ - 0: {1000, 10, 3, 0, 0}, - 1: {200, 10, 0, 600000, 0}, - 2: {500, 10, 2, 555555, 10 * time.Millisecond}, - } - for i, c := range cases { - // Setup the stats handler - st := &stats{} - // Create the throttler - limit := MemThresholds(&runtime.MemStats{NumGC: c.gc, TotalAlloc: c.total}) - th := MemStats(limit, c.rate) - th.DeniedHandler = http.HandlerFunc(st.DeniedHTTP) - // Run the test - b := commands.Boom{ - Req: &commands.ReqOpts{}, - N: c.n, - C: c.c, - Output: "quiet", - } - rpts := runTest(th.Throttle(st), b) - // Assert results - assertStats(t, i, st, rpts) - assertMem(t, i, limit) - } -} - -func assertMem(t *testing.T, ix int, limit *runtime.MemStats) { - var mem runtime.MemStats - runtime.ReadMemStats(&mem) - if mem.NumGC < limit.NumGC { - t.Errorf("%d: expected gc to be at least %d, got %d", ix, limit.NumGC, mem.NumGC) - } - if mem.TotalAlloc < limit.TotalAlloc { - t.Errorf("%d: expected total alloc to be at least %dKb, got %dKb", ix, limit.TotalAlloc/1024, mem.TotalAlloc/1024) - } -} - -func BenchmarkReadMemStats(b *testing.B) { - var mem runtime.MemStats - for i := 0; i < b.N; i++ { - runtime.ReadMemStats(&mem) - } -} diff --git a/Godeps/_workspace/src/gopkg.in/throttled/throttled.v1/rate_test.go b/Godeps/_workspace/src/gopkg.in/throttled/throttled.v1/rate_test.go deleted file mode 100644 index 67dea74b1..000000000 --- a/Godeps/_workspace/src/gopkg.in/throttled/throttled.v1/rate_test.go +++ /dev/null @@ -1,101 +0,0 @@ -package throttled - -import ( - "net/http" - "net/http/httptest" - "strconv" - "testing" - "time" -) - -const deniedStatus = 429 - -// Simple memory store for tests, unsafe for concurrent access -type mapStore struct { - cnt map[string]int - ts map[string]time.Time -} - -func newMapStore() *mapStore { - return &mapStore{ - make(map[string]int), - make(map[string]time.Time), - } -} -func (ms *mapStore) Incr(key string, window time.Duration) (int, int, error) { - if _, ok := ms.cnt[key]; !ok { - return 0, 0, ErrNoSuchKey - } - ms.cnt[key]++ - ts := ms.ts[key] - return ms.cnt[key], RemainingSeconds(ts, window), nil -} -func (ms *mapStore) Reset(key string, win time.Duration) error { - ms.cnt[key] = 1 - ms.ts[key] = time.Now().UTC() - return nil -} - -func TestRateLimit(t *testing.T) { - quota := Q{5, 5 * time.Second} - cases := []struct { - limit, remain, reset, status int - }{ - 0: {5, 4, 5, 200}, - 1: {5, 3, 4, 200}, - 2: {5, 2, 4, 200}, - 3: {5, 1, 3, 200}, - 4: {5, 0, 3, 200}, - 5: {5, 0, 2, deniedStatus}, - } - // Limit the requests to 2 per second - th := Interval(PerSec(2), 0, nil, 0) - // Rate limit - rl := RateLimit(quota, nil, newMapStore()) - // Create the stats - st := &stats{} - // Create the handler - h := th.Throttle(rl.Throttle(st)) - - // Start the server - srv := httptest.NewServer(h) - defer srv.Close() - for i, c := range cases { - callRateLimited(t, i, c.limit, c.remain, c.reset, c.status, srv.URL) - } - // Wait 3 seconds and call again, should start a new window - time.Sleep(3 * time.Second) - callRateLimited(t, len(cases), 5, 4, 5, 200, srv.URL) -} - -func callRateLimited(t *testing.T, i, limit, remain, reset, status int, url string) { - res, err := http.Get(url) - if err != nil { - t.Fatal(err) - } - defer res.Body.Close() - // Assert status code - if status != res.StatusCode { - t.Errorf("%d: expected status %d, got %d", i, status, res.StatusCode) - } - // Assert headers - if v := res.Header.Get("X-RateLimit-Limit"); v != strconv.Itoa(limit) { - t.Errorf("%d: expected limit header to be %d, got %s", i, limit, v) - } - if v := res.Header.Get("X-RateLimit-Remaining"); v != strconv.Itoa(remain) { - t.Errorf("%d: expected remain header to be %d, got %s", i, remain, v) - } - // Allow 1 second wiggle room - v := res.Header.Get("X-RateLimit-Reset") - vi, _ := strconv.Atoi(v) - if vi < reset-1 || vi > reset+1 { - t.Errorf("%d: expected reset header to be close to %d, got %d", i, reset, vi) - } - if status == deniedStatus { - v := res.Header.Get("Retry-After") - vi, _ := strconv.Atoi(v) - if vi < reset-1 || vi > reset+1 { - t.Errorf("%d: expected retry after header to be close to %d, got %d", i, reset, vi) - } - } -} diff --git a/Godeps/_workspace/src/gopkg.in/throttled/throttled.v1/store/mem_test.go b/Godeps/_workspace/src/gopkg.in/throttled/throttled.v1/store/mem_test.go deleted file mode 100644 index e8ef8d0da..000000000 --- a/Godeps/_workspace/src/gopkg.in/throttled/throttled.v1/store/mem_test.go +++ /dev/null @@ -1,43 +0,0 @@ -package store - -import ( - "testing" - "time" -) - -func TestMemStore(t *testing.T) { - st := NewMemStore(0) - win := time.Second - - // Reset stores a key with count of 1, current timestamp - err := st.Reset("k", time.Second) - if err != nil { - t.Errorf("expected reset to return nil, got %s", err) - } - cnt, sec1, _ := st.Incr("k", win) - if cnt != 2 { - t.Errorf("expected reset+incr to set count to 2, got %d", cnt) - } - - // Incr increments the key, keeps same timestamp - cnt, sec2, err := st.Incr("k", win) - if err != nil { - t.Errorf("expected 2nd incr to return nil error, got %s", err) - } - if cnt != 3 { - t.Errorf("expected 2nd incr to return 3, got %d", cnt) - } - if sec1 != sec2 { - t.Errorf("expected 2nd incr to return %d secs, got %d", sec1, sec2) - } - - // Reset on existing key brings it back to 1, new timestamp - err = st.Reset("k", win) - if err != nil { - t.Errorf("expected reset on existing key to return nil, got %s", err) - } - cnt, _, _ = st.Incr("k", win) - if cnt != 2 { - t.Errorf("expected last reset+incr to return 2, got %d", cnt) - } -} diff --git a/Godeps/_workspace/src/gopkg.in/throttled/throttled.v1/store/redis_test.go b/Godeps/_workspace/src/gopkg.in/throttled/throttled.v1/store/redis_test.go deleted file mode 100644 index a282d6d25..000000000 --- a/Godeps/_workspace/src/gopkg.in/throttled/throttled.v1/store/redis_test.go +++ /dev/null @@ -1,66 +0,0 @@ -package store - -import ( - "testing" - "time" - - "github.com/garyburd/redigo/redis" -) - -func getPool() *redis.Pool { - pool := &redis.Pool{ - MaxIdle: 3, - IdleTimeout: 30 * time.Second, - Dial: func() (redis.Conn, error) { - return redis.Dial("tcp", ":6379") - }, - TestOnBorrow: func(c redis.Conn, t time.Time) error { - _, err := c.Do("PING") - return err - }, - } - return pool -} - -func TestRedisStore(t *testing.T) { - pool := getPool() - c := pool.Get() - if _, err := redis.String(c.Do("PING")); err != nil { - c.Close() - t.Skip("redis server not available on localhost port 6379") - } - st := NewRedisStore(pool, "throttled:", 1) - win := 2 * time.Second - - // Incr increments the key, even if it does not exist - cnt, secs, err := st.Incr("k", win) - if err != nil { - t.Errorf("expected initial incr to return nil error, got %s", err) - } - if cnt != 1 { - t.Errorf("expected initial incr to return 1, got %d", cnt) - } - if secs != int(win.Seconds()) { - t.Errorf("expected initial incr to return %d secs, got %d", int(win.Seconds()), secs) - } - - // Waiting a second diminishes the remaining seconds - time.Sleep(time.Second) - _, sec2, _ := st.Incr("k", win) - if sec2 != secs-1 { - t.Errorf("expected 2nd incr after a 1s sleep to return %d secs, got %d", secs-1, sec2) - } - - // Waiting a second so the key expires, Incr should set back to 1, initial secs - time.Sleep(1100 * time.Millisecond) - cnt, sec3, err := st.Incr("k", win) - if err != nil { - t.Errorf("expected last incr to return nil error, got %s", err) - } - if cnt != 1 { - t.Errorf("expected last incr to return 1, got %d", cnt) - } - if sec3 != int(win.Seconds()) { - t.Errorf("expected last incr to return %d secs, got %d", int(win.Seconds()), sec3) - } -} diff --git a/Godeps/_workspace/src/gopkg.in/throttled/throttled.v1/varyby_test.go b/Godeps/_workspace/src/gopkg.in/throttled/throttled.v1/varyby_test.go deleted file mode 100644 index 91b7ae0ae..000000000 --- a/Godeps/_workspace/src/gopkg.in/throttled/throttled.v1/varyby_test.go +++ /dev/null @@ -1,56 +0,0 @@ -package throttled - -import ( - "net/http" - "net/url" - "testing" -) - -func TestVaryBy(t *testing.T) { - u, err := url.Parse("http://localhost/test/path?q=s") - if err != nil { - panic(err) - } - ck := &http.Cookie{Name: "ssn", Value: "test"} - cases := []struct { - vb *VaryBy - r *http.Request - k string - }{ - 0: {nil, &http.Request{}, ""}, - 1: {&VaryBy{RemoteAddr: true}, &http.Request{RemoteAddr: "::"}, "::\n"}, - 2: { - &VaryBy{Method: true, Path: true}, - &http.Request{Method: "POST", URL: u}, - "post\n/test/path\n", - }, - 3: { - &VaryBy{Headers: []string{"Content-length"}}, - &http.Request{Header: http.Header{"Content-Type": []string{"text/plain"}, "Content-Length": []string{"123"}}}, - "123\n", - }, - 4: { - &VaryBy{Separator: ",", Method: true, Headers: []string{"Content-length"}, Params: []string{"q", "user"}}, - &http.Request{Method: "GET", Header: http.Header{"Content-Type": []string{"text/plain"}, "Content-Length": []string{"123"}}, Form: url.Values{"q": []string{"s"}, "pwd": []string{"secret"}, "user": []string{"test"}}}, - "get,123,s,test,", - }, - 5: { - &VaryBy{Cookies: []string{"ssn"}}, - &http.Request{Header: http.Header{"Cookie": []string{ck.String()}}}, - "test\n", - }, - 6: { - &VaryBy{Cookies: []string{"ssn"}, RemoteAddr: true, Custom: func(r *http.Request) string { - return "blah" - }}, - &http.Request{Header: http.Header{"Cookie": []string{ck.String()}}}, - "blah", - }, - } - for i, c := range cases { - got := c.vb.Key(c.r) - if got != c.k { - t.Errorf("%d: expected '%s' (%d), got '%s' (%d)", i, c.k, len(c.k), got, len(got)) - } - } -} -- cgit v1.2.3-1-g7c22