CodeNarc Report

[SRC]def 'should be array type'() {

[MSG]Method "should be array type" has a dynamic return type

[SRC]def 'should construct empty array'() {

[MSG]Method "should construct empty array" has a dynamic return type

[SRC]def array = new BsonArray()

[MSG]The type is not specified for variable "array"

[SRC]def 'should construct from a list'() {

[MSG]Method "should construct from a list" has a dynamic return type

[SRC]def list = [BsonBoolean.TRUE, BsonBoolean.FALSE]

[MSG]The type is not specified for variable "list"

[SRC]def array = new BsonArray(list)

[MSG]The type is not specified for variable "array"

[SRC]def 'should parse json'() {

[MSG]Method "should parse json" has a dynamic return type

[SRC]def 'should skip value #value'() {

[MSG]Method "should skip value #value" has a dynamic return type

[SRC]def document = new BsonDocument('name', value)

[MSG]The type is not specified for variable "document"

[SRC]def reader = new BsonBinaryReader(toBson(document))

[MSG]The type is not specified for variable "reader"

[SRC]def 'should be uuid only for legacy and uuid types'() {

[MSG]Method "should be uuid only for legacy and uuid types" has a dynamic return type

[SRC]def setup() {

[MSG]Method "setup" has a dynamic return type

[SRC]def 'should read all types'() {

[MSG]Method "should read all types" has a dynamic return type

[SRC]def doc = new BsonDocument(

[MSG]The type is not specified for variable "doc"

[SRC]def decodedDoc = new BsonDocumentCodec().decode(new Bson..r().build())

[MSG]The type is not specified for variable "decodedDoc"

[SRC]def 'should fail, ReadBSONType can only be called when S..t VALUE'() {

[MSG]Method "should fail, ReadBSONType can only be called when State is TYPE, not VALUE" has a dynamic return type

[SRC]def reader = new BsonDocumentReader(nullDoc)

[MSG]The type is not specified for variable "reader"

[SRC]def 'should fail, ReadBSONType can only be called when S..ot NAME'() {

[MSG]Method "should fail, ReadBSONType can only be called when State is TYPE, not NAME" has a dynamic return type

[SRC]def reader = new BsonDocumentReader(nullDoc)

[MSG]The type is not specified for variable "reader"

[SRC]def 'conversion methods should behave correctly for the ..py path'() {

[MSG]Method "conversion methods should behave correctly for the happy path" has a dynamic return type

[SRC]def bsonNull = new BsonNull()

[MSG]The type is not specified for variable "bsonNull"

[SRC]def bsonInt32 = new BsonInt32(42)

[MSG]The type is not specified for variable "bsonInt32"

[SRC]def bsonInt64 = new BsonInt64(52L)

[MSG]The type is not specified for variable "bsonInt64"

[SRC]def bsonDecimal128 = new BsonDecimal128(Decimal128.parse('1.0'))

[MSG]The type is not specified for variable "bsonDecimal128"

[SRC]def bsonBoolean = new BsonBoolean(true)

[MSG]The type is not specified for variable "bsonBoolean"

[SRC]def bsonDateTime = new BsonDateTime(new Date().getTime())

[MSG]The type is not specified for variable "bsonDateTime"

[SRC]def bsonDouble = new BsonDouble(62.0)

[MSG]The type is not specified for variable "bsonDouble"

[SRC]def bsonString = new BsonString('the fox ...')

[MSG]The type is not specified for variable "bsonString"

[SRC]def minKey = new BsonMinKey()

[MSG]The type is not specified for variable "minKey"

[SRC]def maxKey = new BsonMaxKey()

[MSG]The type is not specified for variable "maxKey"

[SRC]def javaScript = new BsonJavaScript('int i = 0;')

[MSG]The type is not specified for variable "javaScript"

[SRC]def objectId = new BsonObjectId(new ObjectId())

[MSG]The type is not specified for variable "objectId"

[SRC]def scope = new BsonJavaScriptWithScope('int x = y', new..onInt32(1)))

[MSG]The type is not specified for variable "scope"

[SRC]def regularExpression = new BsonRegularExpression('^test..*xyz$', 'i')

[MSG]The type is not specified for variable "regularExpression"

[SRC]def symbol = new BsonSymbol('ruby stuff')

[MSG]The type is not specified for variable "symbol"

[SRC]def timestamp = new BsonTimestamp(0x12345678, 5)

[MSG]The type is not specified for variable "timestamp"

[SRC]def undefined = new BsonUndefined()

[MSG]The type is not specified for variable "undefined"

[SRC]def binary = new BsonBinary((byte) 80, [5, 4, 3, 2, 1] as byte[])

[MSG]The type is not specified for variable "binary"

[SRC]def bsonArray = new BsonArray([new BsonInt32(1), new Bso..olean(true),

[MSG]The type is not specified for variable "bsonArray"

[SRC]def bsonDocument = new BsonDocument('a', new BsonInt32(1))

[MSG]The type is not specified for variable "bsonDocument"

[SRC]def root = new BsonDocument(

[MSG]The type is not specified for variable "root"

[SRC]def 'is<type> methods should return false for missing keys'() {

[MSG]Method "is<type> methods should return false for missing keys" has a dynamic return type

[SRC]def root = new BsonDocument()

[MSG]The type is not specified for variable "root"

[SRC]!root.isNull('null')

[MSG]The statement on line 150 in class org.bson.BsonDocumentSpecification is at the incorrect indent level: Expected column 9 but was 13

[SRC]!root.isNumber('number')

[MSG]The statement on line 151 in class org.bson.BsonDocumentSpecification is at the incorrect indent level: Expected column 9 but was 13

[SRC]!root.isInt32('int32')

[MSG]The statement on line 152 in class org.bson.BsonDocumentSpecification is at the incorrect indent level: Expected column 9 but was 13

[SRC]!root.isInt64('int64')

[MSG]The statement on line 153 in class org.bson.BsonDocumentSpecification is at the incorrect indent level: Expected column 9 but was 13

[SRC]!root.isDecimal128('decimal128')

[MSG]The statement on line 154 in class org.bson.BsonDocumentSpecification is at the incorrect indent level: Expected column 9 but was 13

[SRC]!root.isBoolean('boolean')

[MSG]The statement on line 155 in class org.bson.BsonDocumentSpecification is at the incorrect indent level: Expected column 9 but was 13

[SRC]!root.isDateTime('date')

[MSG]The statement on line 156 in class org.bson.BsonDocumentSpecification is at the incorrect indent level: Expected column 9 but was 13

[SRC]!root.isDouble('double')

[MSG]The statement on line 157 in class org.bson.BsonDocumentSpecification is at the incorrect indent level: Expected column 9 but was 13

[SRC]!root.isString('string')

[MSG]The statement on line 158 in class org.bson.BsonDocumentSpecification is at the incorrect indent level: Expected column 9 but was 13

[SRC]!root.isObjectId('objectId')

[MSG]The statement on line 159 in class org.bson.BsonDocumentSpecification is at the incorrect indent level: Expected column 9 but was 13

[SRC]!root.isTimestamp('timestamp')

[MSG]The statement on line 160 in class org.bson.BsonDocumentSpecification is at the incorrect indent level: Expected column 9 but was 13

[SRC]!root.isBinary('binary')

[MSG]The statement on line 161 in class org.bson.BsonDocumentSpecification is at the incorrect indent level: Expected column 9 but was 13

[SRC]!root.isArray('array')

[MSG]The statement on line 162 in class org.bson.BsonDocumentSpecification is at the incorrect indent level: Expected column 9 but was 13

[SRC]!root.isDocument('document')

[MSG]The statement on line 163 in class org.bson.BsonDocumentSpecification is at the incorrect indent level: Expected column 9 but was 13

[SRC]def 'get methods should return default values for missing keys'() {

[MSG]Method "get methods should return default values for missing keys" has a dynamic return type

[SRC]def bsonNull = new BsonNull()

[MSG]The type is not specified for variable "bsonNull"

[SRC]def bsonInt32 = new BsonInt32(42)

[MSG]The type is not specified for variable "bsonInt32"

[SRC]def bsonInt64 = new BsonInt64(52L)

[MSG]The type is not specified for variable "bsonInt64"

[SRC]def bsonDecimal128 = new BsonDecimal128(Decimal128.parse('1.0'))

[MSG]The type is not specified for variable "bsonDecimal128"

[SRC]def bsonBoolean = new BsonBoolean(true)

[MSG]The type is not specified for variable "bsonBoolean"

[SRC]def bsonDateTime = new BsonDateTime(new Date().getTime())

[MSG]The type is not specified for variable "bsonDateTime"

[SRC]def bsonDouble = new BsonDouble(62.0)

[MSG]The type is not specified for variable "bsonDouble"

[SRC]def bsonString = new BsonString('the fox ...')

[MSG]The type is not specified for variable "bsonString"

[SRC]def objectId = new BsonObjectId(new ObjectId())

[MSG]The type is not specified for variable "objectId"

[SRC]def regularExpression = new BsonRegularExpression('^test..*xyz$', 'i')

[MSG]The type is not specified for variable "regularExpression"

[SRC]def timestamp = new BsonTimestamp(0x12345678, 5)

[MSG]The type is not specified for variable "timestamp"

[SRC]def binary = new BsonBinary((byte) 80, [5, 4, 3, 2, 1] as byte[])

[MSG]The type is not specified for variable "binary"

[SRC]def bsonArray = new BsonArray([new BsonInt32(1), new Bso..olean(true),

[MSG]The type is not specified for variable "bsonArray"

[SRC]def bsonDocument = new BsonDocument('a', new BsonInt32(1))

[MSG]The type is not specified for variable "bsonDocument"

[SRC]def root = new BsonDocument()

[MSG]The type is not specified for variable "root"

[SRC]def 'clone should make a deep copy of all mutable BsonValue types'() {

[MSG]Method "clone should make a deep copy of all mutable BsonValue types" has a dynamic return type

[SRC]def document = new BsonDocument('d', new BsonDocument()...onInt32(1)))

[MSG]The type is not specified for variable "document"

[SRC]def clone = document.clone()

[MSG]The type is not specified for variable "clone"

[SRC]def 'get methods should throw if key is absent'() {

[MSG]Method "get methods should throw if key is absent" has a dynamic return type

[SRC]def root = new BsonDocument()

[MSG]The type is not specified for variable "root"

[SRC]def 'should get first key'() {

[MSG]Method "should get first key" has a dynamic return type

[SRC]def document = new BsonDocument('i', new BsonInt32(2))

[MSG]The type is not specified for variable "document"

[SRC]def 'getFirstKey should throw NoSuchElementException if ..s empty'() {

[MSG]Method "getFirstKey should throw NoSuchElementException if the document is empty" has a dynamic return type

[SRC]def document = new BsonDocument()

[MSG]The type is not specified for variable "document"

[SRC]def 'should create BsonReader'() {

[MSG]Method "should create BsonReader" has a dynamic return type

[SRC]def document = documentWithValuesOfEveryType()

[MSG]The type is not specified for variable "document"

[SRC]def reader = document.asBsonReader()

[MSG]The type is not specified for variable "reader"

[SRC]def 'should serialize and deserialize'() {

[MSG]Method "should serialize and deserialize" has a dynamic return type

[SRC]def document = new BsonDocument('d', new BsonDocument()...onInt32(1)))

[MSG]The type is not specified for variable "document"

[SRC]def baos = new ByteArrayOutputStream()

[MSG]The type is not specified for variable "baos"

[SRC]def oos = new ObjectOutputStream(baos)

[MSG]The type is not specified for variable "oos"

[SRC]def bais = new ByteArrayInputStream(baos.toByteArray())

[MSG]The type is not specified for variable "bais"

[SRC]def ois = new ObjectInputStream(bais)

[MSG]The type is not specified for variable "ois"

[SRC]def deserializedDocument = ois.readObject()

[MSG]The type is not specified for variable "deserializedDocument"

[SRC]def document = new Document()

[MSG]The type is not specified for field "document"

[SRC]def wrapper = new BsonDocumentWrapper(document, new DocumentCodec())

[MSG]The type is not specified for field "wrapper"

[SRC]def 'should serialize and deserialize'() {

[MSG]Method "should serialize and deserialize" has a dynamic return type

[SRC]def baos = new ByteArrayOutputStream()

[MSG]The type is not specified for variable "baos"

[SRC]def oos = new ObjectOutputStream(baos)

[MSG]The type is not specified for variable "oos"

[SRC]def bais = new ByteArrayInputStream(baos.toByteArray())

[MSG]The type is not specified for variable "bais"

[SRC]def ois = new ObjectInputStream(bais)

[MSG]The type is not specified for variable "ois"

[SRC]def deserializedDocument = ois.readObject()

[MSG]The type is not specified for variable "deserializedDocument"

[SRC]def 'should write all types'() {

[MSG]Method "should write all types" has a dynamic return type

[SRC]def encodedDoc = new BsonDocument();

[MSG]The type is not specified for variable "encodedDoc"

[SRC]def 'should pipe all types'() {

[MSG]Method "should pipe all types" has a dynamic return type

[SRC]def document = new BsonDocument()

[MSG]The type is not specified for variable "document"

[SRC]def reader = new BsonDocumentReader(documentWithValuesOfEveryType())

[MSG]The type is not specified for variable "reader"

[SRC]def writer = new BsonDocumentWriter(document)

[MSG]The type is not specified for variable "writer"

[SRC]def 'should pipe all types with extra elements'() {

[MSG]Method "should pipe all types with extra elements" has a dynamic return type

[SRC]def document = new BsonDocument()

[MSG]The type is not specified for variable "document"

[SRC]def reader = new BsonDocumentReader(new BsonDocument())

[MSG]The type is not specified for variable "reader"

[SRC]def writer = new BsonDocumentWriter(document)

[MSG]The type is not specified for variable "writer"

[SRC]def extraElements = []

[MSG]The type is not specified for variable "extraElements"

[SRC]def 'should convert to int value'() {

[MSG]Method "should convert to int value" has a dynamic return type

[SRC]def 'should convert to long value'() {

[MSG]Method "should convert to long value" has a dynamic return type

[SRC]def 'should convert to double value'() {

[MSG]Method "should convert to double value" has a dynamic return type

[SRC]def 'should convert to decimal128 value'() {

[MSG]Method "should convert to decimal128 value" has a dynamic return type

[SRC]def 'should get type'() {

[MSG]Method "should get type" has a dynamic return type

[SRC]def 'should sort options'() {

[MSG]Method "should sort options" has a dynamic return type

[SRC]def 'should accept invalid options'() {

[MSG]Method "should accept invalid options" has a dynamic return type

[SRC]def 'should allow null options'() {

[MSG]Method "should allow null options" has a dynamic return type

[SRC]def 'should get regular expression'() {

[MSG]Method "should get regular expression" has a dynamic return type

[SRC]def 'equivalent values should be equal and have same hashcode'() {

[MSG]Method "equivalent values should be equal and have same hashcode" has a dynamic return type

[SRC]def first = new BsonRegularExpression('abc', 'uxsmi')

[MSG]The type is not specified for variable "first"

[SRC]def second = new BsonRegularExpression('abc', 'imsxu')

[MSG]The type is not specified for variable "second"

[SRC]def 'should convert to string'() {

[MSG]Method "should convert to string" has a dynamic return type

[SRC]def 'bsonType should get expected value'() {

[MSG]Method "bsonType should get expected value" has a dynamic return type

[SRC]def 'compareTo should sort the timestamps as unsigned values'() {

[MSG]Method "compareTo should sort the timestamps as unsigned values" has a dynamic return type

[SRC]def timestamps = [new BsonTimestamp(Long.MIN_VALUE),

[MSG]The type is not specified for variable "timestamps"

[SRC]def 'constructors should initialize instance'() {

[MSG]Method "constructors should initialize instance" has a dynamic return type

[SRC]def tsFromValue = new BsonTimestamp(value)

[MSG]The type is not specified for variable "tsFromValue"

[SRC]def tsFromSecondsAndIncrement = new BsonTimestamp(seconds, increment)

[MSG]The type is not specified for variable "tsFromSecondsAndIncrement"

[SRC]def 'no args constructor should initialize instance'() {

[MSG]Method "no args constructor should initialize instance" has a dynamic return type

[SRC]def tsFromValue = new BsonTimestamp()

[MSG]The type is not specified for variable "tsFromValue"

[SRC]def 'is methods should return true for the correct type'() {

[MSG]Method "is methods should return true for the correct type" has a dynamic return type

[SRC]def 'is methods should return false for the incorrect type'() {

[MSG]Method "is methods should return false for the incorrect type" has a dynamic return type

[SRC]def 'as methods should return false for the incorrect type'() {

[MSG]Method "as methods should return false for the incorrect type" has a dynamic return type

[SRC]def shouldThrowExceptionForBooleanWhenWritingBeforeStart..Document() {

[MSG]Method "shouldThrowExceptionForBooleanWhenWritingBeforeStartingDocument" has a dynamic return type

[SRC]def shouldThrowExceptionForArrayWhenWritingBeforeStartingDocument() {

[MSG]Method "shouldThrowExceptionForArrayWhenWritingBeforeStartingDocument" has a dynamic return type

[SRC]def shouldThrowExceptionForNullWhenWritingBeforeStartingDocument() {

[MSG]Method "shouldThrowExceptionForNullWhenWritingBeforeStartingDocument" has a dynamic return type

[SRC]def shouldThrowExceptionForStringWhenStateIsValue() {

[MSG]Method "shouldThrowExceptionForStringWhenStateIsValue" has a dynamic return type

[SRC]def shouldThrowExceptionWhenEndingAnArrayWhenStateIsValue() {

[MSG]Method "shouldThrowExceptionWhenEndingAnArrayWhenStateIsValue" has a dynamic return type

[SRC]def shouldThrowExceptionWhenWritingASecondName() {

[MSG]Method "shouldThrowExceptionWhenWritingASecondName" has a dynamic return type

[SRC]def shouldThrowExceptionWhenEndingADocumentBeforeValueIsWritten() {

[MSG]Method "shouldThrowExceptionWhenEndingADocumentBeforeValueIsWritten" has a dynamic return type

[SRC]def shouldThrowAnExceptionWhenTryingToWriteASecondValue() {

[MSG]Method "shouldThrowAnExceptionWhenTryingToWriteASecondValue" has a dynamic return type

[SRC]def shouldThrowAnExceptionWhenTryingToWriteJavaScript() {

[MSG]Method "shouldThrowAnExceptionWhenTryingToWriteJavaScript" has a dynamic return type

[SRC]def shouldThrowAnExceptionWhenWritingANameInAnArray() {

[MSG]Method "shouldThrowAnExceptionWhenWritingANameInAnArray" has a dynamic return type

[SRC]def shouldThrowAnExceptionWhenEndingDocumentInTheMiddleO..gAnArray() {

[MSG]Method "shouldThrowAnExceptionWhenEndingDocumentInTheMiddleOfWritingAnArray" has a dynamic return type

[SRC]def shouldThrowAnExceptionWhenEndingAnArrayInASubDocument() {

[MSG]Method "shouldThrowAnExceptionWhenEndingAnArrayInASubDocument" has a dynamic return type

[SRC]def shouldThrowAnExceptionWhenWritingANameInAnArrayEvenW..sInArray() {

[MSG]Method "shouldThrowAnExceptionWhenWritingANameInAnArrayEvenWhenSubDocumentExistsInArray" has a dynamic return type

[SRC]def shouldThrowExceptionWhenWritingObjectsIntoNestedArrays() {

[MSG]Method "shouldThrowExceptionWhenWritingObjectsIntoNestedArrays" has a dynamic return type

[SRC]def shouldThrowAnExceptionWhenAttemptingToEndAnArrayThat..tStarted() {

[MSG]Method "shouldThrowAnExceptionWhenAttemptingToEndAnArrayThatWasNotStarted" has a dynamic return type

[SRC]def shouldThrowAnErrorIfTryingToWriteNamesIntoAJavascriptScope1() {

[MSG]Method "shouldThrowAnErrorIfTryingToWriteNamesIntoAJavascriptScope1" has a dynamic return type

[SRC]def shouldThrowAnErrorIfTryingToWriteNamesIntoAJavascriptScope2() {

[MSG]Method "shouldThrowAnErrorIfTryingToWriteNamesIntoAJavascriptScope2" has a dynamic return type

[SRC]def shouldThrowAnErrorIfTryingToWriteNamesIntoAJavascriptScope3() {

[MSG]Method "shouldThrowAnErrorIfTryingToWriteNamesIntoAJavascriptScope3" has a dynamic return type

[SRC]def shouldThrowAnErrorIfTryingToWriteNamesIntoAJavascriptScope4() {

[MSG]Method "shouldThrowAnErrorIfTryingToWriteNamesIntoAJavascriptScope4" has a dynamic return type

[SRC]def shouldThrowAnErrorIfKeyContainsNullCharacter() {

[MSG]Method "shouldThrowAnErrorIfKeyContainsNullCharacter" has a dynamic return type

[SRC]def shouldNotThrowAnErrorIfValueContainsNullCharacter() {

[MSG]Method "shouldNotThrowAnErrorIfValueContainsNullCharacter" has a dynamic return type

[SRC]def shouldNotThrowAnExceptionIfCorrectlyStartingAndEndin..ocuments() {

[MSG]Method "shouldNotThrowAnExceptionIfCorrectlyStartingAndEndingDocumentsAndSubDocuments" has a dynamic return type

[SRC]def shouldThrowOnInvalidFieldName() {

[MSG]Method "shouldThrowOnInvalidFieldName" has a dynamic return type

[SRC]def shouldThrowOnInvalidFieldNameNestedInDocument() {

[MSG]Method "shouldThrowOnInvalidFieldNameNestedInDocument" has a dynamic return type

[SRC]def shouldThrowOnInvalidFieldNameNestedInDocumentInArray() {

[MSG]Method "shouldThrowOnInvalidFieldNameNestedInDocumentInArray" has a dynamic return type

[SRC]def 'should throw if mark without resetting previous mar..er writer) {

[MSG]Method "should throw if mark without resetting previous mark" has a dynamic return type

[SRC]def 'should throw if reset without mark'(BsonWriter writer) {

[MSG]Method "should throw if reset without mark" has a dynamic return type

[SRC]def 'Lookahead should work at various states'(BsonWriter writer) {

[MSG]Method "Lookahead should work at various states" has a dynamic return type

[SRC]def 'Lookahead should work at various states with Mark'(..er writer) {

[MSG]Method "Lookahead should work at various states with Mark" has a dynamic return type

[SRC]def 'should peek binary subtype and size'(BsonWriter writer) {

[MSG]Method "should peek binary subtype and size" has a dynamic return type

[SRC]def subType = reader.peekBinarySubType()

[MSG]The type is not specified for variable "subType"

[SRC]def size = reader.peekBinarySize()

[MSG]The type is not specified for variable "size"

[SRC]def binary = reader.readBinaryData()

[MSG]The type is not specified for variable "binary"

[SRC]def longValue = reader.readInt64('int64')

[MSG]The type is not specified for variable "longValue"

[SRC]static emptyDocument = new BsonDocument()

[MSG]The type is not specified for field "emptyDocument"

[SRC]static emptyRawDocument = new RawBsonDocument(emptyDocum..entCodec());

[MSG]The type is not specified for field "emptyRawDocument"

[SRC]static document = new BsonDocument()

[MSG]The type is not specified for field "document"

[SRC]def 'constructors should throw if parameters are invalid'() {

[MSG]Method "constructors should throw if parameters are invalid" has a dynamic return type

[SRC]def 'byteBuffer should contain the correct bytes'() {

[MSG]Method "byteBuffer should contain the correct bytes" has a dynamic return type

[SRC]def byteBuf = rawDocument.getByteBuffer()

[MSG]The type is not specified for variable "byteBuf"

[SRC]def actualBytes = new byte[58]

[MSG]The type is not specified for variable "actualBytes"

[SRC]def 'parse should through if parameter is invalid'() {

[MSG]Method "parse should through if parameter is invalid" has a dynamic return type

[SRC]def 'should parse json'() {

[MSG]Method "should parse json" has a dynamic return type

[SRC]def 'containKey should throw if the key name is null'() {

[MSG]Method "containKey should throw if the key name is null" has a dynamic return type

[SRC]def 'containsKey should find an existing key'() {

[MSG]Method "containsKey should find an existing key" has a dynamic return type

[SRC]def 'containsKey should not find a non-existing key'() {

[MSG]Method "containsKey should not find a non-existing key" has a dynamic return type

[SRC]def 'containValue should find an existing value'() {

[MSG]Method "containValue should find an existing value" has a dynamic return type

[SRC]def 'containValue should not find a non-existing value'() {

[MSG]Method "containValue should not find a non-existing value" has a dynamic return type

[SRC]def 'isEmpty should return false when the document is not empty'() {

[MSG]Method "isEmpty should return false when the document is not empty" has a dynamic return type

[SRC]def 'isEmpty should return true when the document is empty'() {

[MSG]Method "isEmpty should return true when the document is empty" has a dynamic return type

[SRC]def 'should get correct size when the document is empty'() {

[MSG]Method "should get correct size when the document is empty" has a dynamic return type

[SRC]def 'should get correct key set when the document is empty'() {

[MSG]Method "should get correct key set when the document is empty" has a dynamic return type

[SRC]def 'should get correct values set when the document is empty'() {

[MSG]Method "should get correct values set when the document is empty" has a dynamic return type

[SRC]def 'should get correct entry set when the document is empty'() {

[MSG]Method "should get correct entry set when the document is empty" has a dynamic return type

[SRC]def 'should get correct size'() {

[MSG]Method "should get correct size" has a dynamic return type

[SRC]def 'should get correct key set'() {

[MSG]Method "should get correct key set" has a dynamic return type

[SRC]def 'should get correct values set'() {

[MSG]Method "should get correct values set" has a dynamic return type

[SRC]def 'should get correct entry set'() {

[MSG]Method "should get correct entry set" has a dynamic return type

[SRC]def 'should get first key'() {

[MSG]Method "should get first key" has a dynamic return type

[SRC]def 'getFirstKey should throw NoSuchElementException if ..s empty'() {

[MSG]Method "getFirstKey should throw NoSuchElementException if the document is empty" has a dynamic return type

[SRC]def 'should create BsonReader'() {

[MSG]Method "should create BsonReader" has a dynamic return type

[SRC]def reader = document.asBsonReader()

[MSG]The type is not specified for variable "reader"

[SRC]def 'toJson should return equivalent JSON'() {

[MSG]Method "toJson should return equivalent JSON" has a dynamic return type

[SRC]def 'toJson should respect default JsonWriterSettings'() {

[MSG]Method "toJson should respect default JsonWriterSettings" has a dynamic return type

[SRC]def writer = new StringWriter();

[MSG]The type is not specified for variable "writer"

[SRC]def 'toJson should respect JsonWriterSettings'() {

[MSG]Method "toJson should respect JsonWriterSettings" has a dynamic return type

[SRC]def jsonWriterSettings = new JsonWriterSettings(JsonMode.SHELL)

[MSG]The type is not specified for variable "jsonWriterSettings"

[SRC]def writer = new StringWriter();

[MSG]The type is not specified for variable "writer"

[SRC]def 'all write methods should throw UnsupportedOperationException'() {

[MSG]Method "all write methods should throw UnsupportedOperationException" has a dynamic return type

[SRC]def rawDocument = createRawDocumenFromDocument()

[MSG]The type is not specified for variable "rawDocument"

[SRC]def 'should decode'() {

[MSG]Method "should decode" has a dynamic return type

[SRC]def 'hashCode should equal hash code of identical BsonDocument'() {

[MSG]Method "hashCode should equal hash code of identical BsonDocument" has a dynamic return type

[SRC]def 'equals should equal identical BsonDocument'() {

[MSG]Method "equals should equal identical BsonDocument" has a dynamic return type

[SRC]def 'clone should make a deep copy'() {

[MSG]Method "clone should make a deep copy" has a dynamic return type

[SRC]def 'should serialize and deserialize'() {

[MSG]Method "should serialize and deserialize" has a dynamic return type

[SRC]def baos = new ByteArrayOutputStream()

[MSG]The type is not specified for variable "baos"

[SRC]def oos = new ObjectOutputStream(baos)

[MSG]The type is not specified for variable "oos"

[SRC]def bais = new ByteArrayInputStream(baos.toByteArray())

[MSG]The type is not specified for variable "bais"

[SRC]def ois = new ObjectInputStream(bais)

[MSG]The type is not specified for variable "ois"

[SRC]def deserializedDocument = ois.readObject()

[MSG]The type is not specified for variable "deserializedDocument"

[MSG]Code block ends with a blank line.

[SRC]def strippedBytes = new byte[size]

[MSG]The type is not specified for variable "strippedBytes"

[SRC]def outputBuffer = new BasicOutputBuffer(1024)

[MSG]The type is not specified for variable "outputBuffer"

[SRC]def bytes = outputBuffer.getInternalBuffer()

[MSG]The type is not specified for variable "bytes"

[SRC]def unstrippedBytes = new byte[size + 2]

[MSG]The type is not specified for variable "unstrippedBytes"

[SRC]def 'should encode and decode atomic boolean'() {

[MSG]Method "should encode and decode atomic boolean" has a dynamic return type

[SRC]def codec = new AtomicBooleanCodec()

[MSG]The type is not specified for variable "codec"

[SRC]def atomicBoolean = new AtomicBoolean(true)

[MSG]The type is not specified for variable "atomicBoolean"

[SRC]def document = new BsonDocument()

[MSG]The type is not specified for variable "document"

[SRC]def writer = new BsonDocumentWriter(document)

[MSG]The type is not specified for variable "writer"

[SRC]def reader = new BsonDocumentReader(document)

[MSG]The type is not specified for variable "reader"

[SRC]def value = codec.decode(reader, DecoderContext.builder().build())

[MSG]The type is not specified for variable "value"

[SRC]def 'should encode and decode atomic integer'() {

[MSG]Method "should encode and decode atomic integer" has a dynamic return type

[SRC]def codec = new AtomicIntegerCodec()

[MSG]The type is not specified for variable "codec"

[SRC]def atomicInteger = new AtomicInteger(1)

[MSG]The type is not specified for variable "atomicInteger"

[SRC]def document = new BsonDocument()

[MSG]The type is not specified for variable "document"

[SRC]def writer = new BsonDocumentWriter(document)

[MSG]The type is not specified for variable "writer"

[SRC]def reader = new BsonDocumentReader(document)

[MSG]The type is not specified for variable "reader"

[SRC]def value = codec.decode(reader, DecoderContext.builder().build())

[MSG]The type is not specified for variable "value"

[SRC]def 'should encode and decode atomic long'() {

[MSG]Method "should encode and decode atomic long" has a dynamic return type

[SRC]def codec = new AtomicLongCodec()

[MSG]The type is not specified for variable "codec"

[SRC]def atomicLong = new AtomicLong(1L)

[MSG]The type is not specified for variable "atomicLong"

[SRC]def document = new BsonDocument()

[MSG]The type is not specified for variable "document"

[SRC]def writer = new BsonDocumentWriter(document)

[MSG]The type is not specified for variable "writer"

[SRC]def reader = new BsonDocumentReader(document)

[MSG]The type is not specified for variable "reader"

[SRC]def value = codec.decode(reader, DecoderContext.builder().build())

[MSG]The type is not specified for variable "value"

[SRC]def 'should round trip BigDecimal successfully'() {

[MSG]Method "should round trip BigDecimal successfully" has a dynamic return type

[SRC]def codec = new BigDecimalCodec()

[MSG]The type is not specified for variable "codec"

[SRC]def bsonDecimal128 = new BsonDecimal128(new Decimal128(bigDecimal))

[MSG]The type is not specified for variable "bsonDecimal128"

[SRC]def writer = new BsonDocumentWriter(new BsonDocument())

[MSG]The type is not specified for variable "writer"

[MSG]Code block ends with a blank line.

[SRC]def 'should encode and decode all default types'() {

[MSG]Method "should encode and decode all default types" has a dynamic return type

[SRC]def doc = new BsonDocument(

[MSG]The type is not specified for variable "doc"

[SRC]def decodedDoc = new BsonDocumentCodec().decode(reader, ..r().build())

[MSG]The type is not specified for variable "decodedDoc"

[SRC]def 'should respect encodeIdFirst property in encoder context'() {

[MSG]Method "should respect encodeIdFirst property in encoder context" has a dynamic return type

[SRC]def doc = new BsonDocument(

[MSG]The type is not specified for variable "doc"

[SRC]def encodedDocument = new BsonDocument()

[MSG]The type is not specified for variable "encodedDocument"

[SRC]def 'should encode nested raw documents'() {

[MSG]Method "should encode nested raw documents" has a dynamic return type

[SRC]def doc = new BsonDocument('a', BsonBoolean.TRUE)

[MSG]The type is not specified for variable "doc"

[SRC]def rawDoc = new RawBsonDocument(doc, new BsonDocumentCodec());

[MSG]The type is not specified for variable "rawDoc"

[SRC]def docWithNestedRawDoc = new BsonDocument('a', rawDoc)...st(rawDoc)))

[MSG]The type is not specified for variable "docWithNestedRawDoc"

[SRC]def encodedDocument = new BsonDocument()

[MSG]The type is not specified for variable "encodedDocument"

[SRC]def 'should determine if document has an id'() {

[MSG]Method "should determine if document has an id" has a dynamic return type

[SRC]def 'should get document id'() {

[MSG]Method "should get document id" has a dynamic return type

[SRC]def 'should generate document id if absent'() {

[MSG]Method "should generate document id if absent" has a dynamic return type

[SRC]def document = new BsonDocument()

[MSG]The type is not specified for variable "document"

[SRC]def 'should not generate document id if present'() {

[MSG]Method "should not generate document id if present" has a dynamic return type

[SRC]def document = new BsonDocument('_id', new BsonInt32(1))

[MSG]The type is not specified for variable "document"

[SRC]def 'should have defaults for all BSON types'() {

[MSG]Method "should have defaults for all BSON types" has a dynamic return type

[SRC]def map = new BsonTypeClassMap()

[MSG]The type is not specified for variable "map"

[SRC]def 'should obey replacements'() {

[MSG]Method "should obey replacements" has a dynamic return type

[SRC]def map = new BsonTypeClassMap([(BsonType.DATE_TIME): java.sql.Date])

[MSG]The type is not specified for variable "map"

[SRC]def bsonTypeClassMap = new BsonTypeClassMap()

[MSG]The type is not specified for field "bsonTypeClassMap"

[SRC]def registry = fromRegistries(fromProviders(new Document..Provider()))

[MSG]The type is not specified for field "registry"

[SRC]def bsonTypeCodecMap = new BsonTypeCodecMap(bsonTypeClas..p, registry)

[MSG]The type is not specified for field "bsonTypeCodecMap"

[SRC]def 'should map types to codecs'() {

[MSG]Method "should map types to codecs" has a dynamic return type

[SRC]def 'should throw exception for unmapped type'() {

[MSG]Method "should throw exception for unmapped type" has a dynamic return type

[SRC]def 'should throw exception for unregistered codec'() {

[MSG]Method "should throw exception for unregistered codec" has a dynamic return type

[SRC]def provider = new BsonValueCodecProvider()

[MSG]The type is not specified for field "provider"

[SRC]def codecRegistry = fromProviders(provider)

[MSG]The type is not specified for field "codecRegistry"

[SRC]def 'should get correct codec'() {

[MSG]Method "should get correct codec" has a dynamic return type

[SRC]def 'should get encoder class'() {

[MSG]Method "should get encoder class" has a dynamic return type

[SRC]def 'when encoding a character, should throw if it is null'() {

[MSG]Method "when encoding a character, should throw if it is null" has a dynamic return type

[SRC]def writer = new BsonDocumentWriter(new BsonDocument())

[MSG]The type is not specified for variable "writer"

[SRC]def 'should encode a character'() {

[MSG]Method "should encode a character" has a dynamic return type

[SRC]def writer = new BsonDocumentWriter(new BsonDocument())

[MSG]The type is not specified for variable "writer"

[SRC]def 'should decode a character'() {

[MSG]Method "should decode a character" has a dynamic return type

[SRC]def reader = new BsonDocumentReader(new BsonDocument('st..tring('c')))

[MSG]The type is not specified for variable "reader"

[SRC]def character = codec.decode(reader, DecoderContext.builder().build())

[MSG]The type is not specified for variable "character"

[SRC]def 'when decoding a string whose length is not 1, shoul..ception'() {

[MSG]Method "when decoding a string whose length is not 1, should throw a BsonInvalidOperationException" has a dynamic return type

[SRC]def reader = new BsonDocumentReader(new BsonDocument('st..ring('cc')))

[MSG]The type is not specified for variable "reader"

[SRC]def 'should encode code with scope as java script follow..f scope'() {

[MSG]Method "should encode code with scope as java script followed by document of scope" has a dynamic return type

[SRC]def 'should decode code with scope'() {

[MSG]Method "should decode code with scope" has a dynamic return type

[SRC]def 'should encode and decode all default types with all..er writer) {

[MSG]Method "should encode and decode all default types with all readers and writers" has a dynamic return type

[SRC]def originalDocument = new Document()

[MSG]The type is not specified for variable "originalDocument"

[SRC]def decodedDoc = new DocumentCodec().decode(reader, Deco..r().build())

[MSG]The type is not specified for variable "decodedDoc"

[SRC]def 'should decode binary subtypes for UUID'() {

[MSG]Method "should decode binary subtypes for UUID" has a dynamic return type

[SRC]def reader = new BsonBinaryReader(ByteBuffer.wrap(bytes as byte[]))

[MSG]The type is not specified for variable "reader"

[SRC]def document = new DocumentCodec().decode(reader, Decode..r().build())

[MSG]The type is not specified for variable "document"

[SRC]def 'should respect encodeIdFirst property in encoder context'() {

[MSG]Method "should respect encodeIdFirst property in encoder context" has a dynamic return type

[SRC]def originalDocument = new Document('x', 2)

[MSG]The type is not specified for variable "originalDocument"

[SRC]def encodedDocument = new BsonDocument()

[MSG]The type is not specified for variable "encodedDocument"

[SRC]def 'should apply transformer to decoded values'() {

[MSG]Method "should apply transformer to decoded values" has a dynamic return type

[SRC]def codec = new DocumentCodec(fromProviders([new ValueCo..rovider()]),

[MSG]The type is not specified for variable "codec"

[SRC]def doc = codec.decode(new BsonDocumentReader(new BsonDo..r().build())

[MSG]The type is not specified for variable "doc"

[SRC]def 'should generate id if absent'() {

[MSG]Method "should generate id if absent" has a dynamic return type

[SRC]def document = new Document()

[MSG]The type is not specified for variable "document"

[SRC]def 'should not generate id if present'() {

[MSG]Method "should not generate id if present" has a dynamic return type

[SRC]def document = new Document('_id', 1)

[MSG]The type is not specified for variable "document"

[SRC]def 'should determine if id is present'() {

[MSG]Method "should determine if id is present" has a dynamic return type

[SRC]def 'should get id if present'() {

[MSG]Method "should get id if present" has a dynamic return type

[SRC]def 'should throw if getting id when absent'() {

[MSG]Method "should throw if getting id when absent" has a dynamic return type

[SRC]def 'should provide codec for Iterables'() {

[MSG]Method "should provide codec for Iterables" has a dynamic return type

[SRC]def provider = new IterableCodecProvider()

[MSG]The type is not specified for variable "provider"

[SRC]def registry = fromProviders(provider, new BsonValueCode..cProvider())

[MSG]The type is not specified for variable "registry"

[SRC]def 'should not provide codec for non-Iterables'() {

[MSG]Method "should not provide codec for non-Iterables" has a dynamic return type

[SRC]def provider = new IterableCodecProvider()

[MSG]The type is not specified for variable "provider"

[SRC]def registry = fromProviders(provider, new BsonValueCode..cProvider())

[MSG]The type is not specified for variable "registry"

[SRC]def 'identical instances should be equal and have same hash code'() {

[MSG]Method "identical instances should be equal and have same hash code" has a dynamic return type

[SRC]def first = new IterableCodecProvider()

[MSG]The type is not specified for variable "first"

[SRC]def second = new IterableCodecProvider()

[MSG]The type is not specified for variable "second"

[SRC]def 'unidentical instances should not be equal'() {

[MSG]Method "unidentical instances should not be equal" has a dynamic return type

[SRC]def first = new IterableCodecProvider()

[MSG]The type is not specified for variable "first"

[SRC]def second = new IterableCodecProvider(new BsonTypeClass..N: String]))

[MSG]The type is not specified for variable "second"

[SRC]def third = new IterableCodecProvider(new BsonTypeClassM..ject from ->

[MSG]The type is not specified for variable "third"

[SRC]static final REGISTRY = fromProviders(new ValueCodecProv..cProvider(),

[MSG]The type is not specified for field "REGISTRY"

[SRC]def 'should have Iterable encoding class'() {

[MSG]Method "should have Iterable encoding class" has a dynamic return type

[SRC]def codec = new IterableCodec(REGISTRY, new BsonTypeClassMap())

[MSG]The type is not specified for variable "codec"

[SRC]def 'should encode an Iterable to a BSON array'() {

[MSG]Method "should encode an Iterable to a BSON array" has a dynamic return type

[SRC]def codec = new IterableCodec(REGISTRY, new BsonTypeClassMap())

[MSG]The type is not specified for variable "codec"

[SRC]def writer = new BsonDocumentWriter(new BsonDocument())

[MSG]The type is not specified for variable "writer"

[SRC]def 'should decode a BSON array to an Iterable'() {

[MSG]Method "should decode a BSON array to an Iterable" has a dynamic return type

[SRC]def codec = new IterableCodec(REGISTRY, new BsonTypeClassMap())

[MSG]The type is not specified for variable "codec"

[SRC]def reader = new BsonDocumentReader(parse('{array : [1, ..3, null]}'))

[MSG]The type is not specified for variable "reader"

[SRC]def iterable = codec.decode(reader, DecoderContext.builder().build())

[MSG]The type is not specified for variable "iterable"

[SRC]def 'should decode a BSON array of arrays to an Iterable..erables'() {

[MSG]Method "should decode a BSON array of arrays to an Iterable of Iterables" has a dynamic return type

[SRC]def codec = new IterableCodec(REGISTRY, new BsonTypeClassMap())

[MSG]The type is not specified for variable "codec"

[SRC]def reader = new BsonDocumentReader(parse('{array : [[1,.., 4, 5]]}'))

[MSG]The type is not specified for variable "reader"

[SRC]def iterable = codec.decode(reader, DecoderContext.builder().build())

[MSG]The type is not specified for variable "iterable"

[SRC]def 'should use provided transformer'() {

[MSG]Method "should use provided transformer" has a dynamic return type

[SRC]def codec = new IterableCodec(REGISTRY, new BsonTypeClas..ject from ->

[MSG]The type is not specified for variable "codec"

[SRC]def reader = new BsonDocumentReader(parse('{array : [1, 2, 3]}'))

[MSG]The type is not specified for variable "reader"

[SRC]def iterable = codec.decode(reader, DecoderContext.builder().build())

[MSG]The type is not specified for variable "iterable"

[SRC]def 'should decode binary subtypes for UUID'() {

[MSG]Method "should decode binary subtypes for UUID" has a dynamic return type

[SRC]def codec = new IterableCodec(REGISTRY, new BsonTypeClassMap(), null)

[MSG]The type is not specified for variable "codec"

[SRC]def reader = new BsonDocumentReader(parse(document))

[MSG]The type is not specified for variable "reader"

[SRC]def iterable = codec.decode(reader, DecoderContext.builder().build())

[MSG]The type is not specified for variable "iterable"

[SRC]def 'should encode and decode all default types with all..er writer) {

[MSG]Method "should encode and decode all default types with all readers and writers" has a dynamic return type

[SRC]def originalDocument = [:]

[MSG]The type is not specified for variable "originalDocument"

[SRC]def decodedDoc = new MapCodec().decode(reader, DecoderCo..r().build())

[MSG]The type is not specified for variable "decodedDoc"

[SRC]def 'should decode binary subtypes for UUID'() {

[MSG]Method "should decode binary subtypes for UUID" has a dynamic return type

[SRC]def reader = new BsonBinaryReader(ByteBuffer.wrap(bytes as byte[]))

[MSG]The type is not specified for variable "reader"

[SRC]def document = new MapCodec().decode(reader, DecoderCont..r().build())

[MSG]The type is not specified for variable "document"

[SRC]def 'should apply transformer to decoded values'() {

[MSG]Method "should apply transformer to decoded values" has a dynamic return type

[SRC]def codec = new MapCodec(fromProviders([new ValueCodecPr..rovider()]),

[MSG]The type is not specified for variable "codec"

[SRC]def doc = codec.decode(new BsonDocumentReader(new BsonDo..r().build())

[MSG]The type is not specified for variable "doc"

[SRC]def codec = new RawBsonDocumentCodec()

[MSG]The type is not specified for field "codec"

[SRC]def document = new BsonDocument([new BsonElement('b1', B..ean.FALSE)])

[MSG]The type is not specified for field "document"

[SRC]def documentBytes = [15, 0, 0, 0, 8, 98, 49, 0, 1, 8, 98..] as byte[];

[MSG]The type is not specified for field "documentBytes"

[SRC]def 'should get encoder class'() {

[MSG]Method "should get encoder class" has a dynamic return type

[SRC]def 'should encode'() {

[MSG]Method "should encode" has a dynamic return type

[SRC]def document = new BsonDocument()

[MSG]The type is not specified for variable "document"

[SRC]def writer = new BsonDocumentWriter(document)

[MSG]The type is not specified for variable "writer"

[SRC]def 'should decode'() {

[MSG]Method "should decode" has a dynamic return type

[SRC]def reader = new BsonBinaryReader(new ByteBufferBsonInpu..entBytes))))

[MSG]The type is not specified for variable "reader"

[SRC]def bytes = new byte[buffer.getByteBuffer().remaining()]

[MSG]The type is not specified for variable "bytes"

[SRC]def 'should return Undefined class'() {

[MSG]Method "should return Undefined class" has a dynamic return type

[SRC]def 'should decode undefined type from BsonReader'() {

[MSG]Method "should decode undefined type from BsonReader" has a dynamic return type

[SRC]def result = codec.decode(reader, DecoderContext.builder().build())

[MSG]The type is not specified for variable "result"

[SRC]def 'should encode undefined type to BsonWriter'() {

[MSG]Method "should encode undefined type to BsonWriter" has a dynamic return type

[SRC]def setup() {

[MSG]Method "setup" has a dynamic return type

[SRC]def 'should decode different types of UUID'(UuidCodec co..OException {

[MSG]Method "should decode different types of UUID" has a dynamic return type

[MSG]Code block starts with a blank line.

[MSG]Code block ends with a blank line.

[SRC]def 'should encode different types of UUIDs'(Byte bsonSubType,

[MSG]Method "should encode different types of UUIDs" has a dynamic return type

[SRC]private final provider = new ValueCodecProvider()

[MSG]The type is not specified for field "provider"

[SRC]private final registry = CodecRegistries.fromProviders(provider)

[MSG]The type is not specified for field "registry"

[SRC]def 'should provide supported codecs'() {

[MSG]Method "should provide supported codecs" has a dynamic return type

[SRC]def 'fromCodec should return a SingleCodecRegistry'() {

[MSG]Method "fromCodec should return a SingleCodecRegistry" has a dynamic return type

[SRC]def registry = fromCodecs(new UuidCodec(), new LongCodec())

[MSG]The type is not specified for variable "registry"

[SRC]def 'fromProvider should return ProvidersCodecRegistry'() {

[MSG]Method "fromProvider should return ProvidersCodecRegistry" has a dynamic return type

[SRC]def registry = fromProviders(new BsonValueCodecProvider())

[MSG]The type is not specified for variable "registry"

[SRC]def 'fromProviders should return ProvidersCodecRegistry'() {

[MSG]Method "fromProviders should return ProvidersCodecRegistry" has a dynamic return type

[SRC]def providers = fromProviders([new BsonValueCodecProvide..Provider()])

[MSG]The type is not specified for variable "providers"

[SRC]def 'fromRegistries should return ProvidersCodecRegistry'() {

[MSG]Method "fromRegistries should return ProvidersCodecRegistry" has a dynamic return type

[SRC]def uuidCodec = new UuidCodec()

[MSG]The type is not specified for variable "uuidCodec"

[SRC]def registry = fromRegistries(fromCodecs(uuidCodec), fro..Provider()))

[MSG]The type is not specified for variable "registry"

[SRC]def 'should return the cached codec if a codec for the c.. exists'() {

[MSG]Method "should return the cached codec if a codec for the class exists" has a dynamic return type

[SRC]def codec = new MinKeyCodec()

[MSG]The type is not specified for variable "codec"

[SRC]def cache = new CodecCache()

[MSG]The type is not specified for variable "cache"

[SRC]def 'should throw if codec for class does not exist'() {

[MSG]Method "should throw if codec for class does not exist" has a dynamic return type

[SRC]def cache = new CodecCache()

[MSG]The type is not specified for variable "cache"

[SRC]def 'should throw if supplied codecProviders is null or ..ty list'() {

[MSG]Method "should throw if supplied codecProviders is null or an empty list" has a dynamic return type

[SRC]def 'should throw a CodecConfigurationException if codec..t found'() {

[MSG]Method "should throw a CodecConfigurationException if codec not found" has a dynamic return type

[SRC]def 'get should return registered codec'() {

[MSG]Method "get should return registered codec" has a dynamic return type

[SRC]def minKeyCodec = new MinKeyCodec()

[MSG]The type is not specified for variable "minKeyCodec"

[SRC]def registry = new ProvidersCodecRegistry([new SingleCod..nKeyCodec)])

[MSG]The type is not specified for variable "registry"

[SRC]def 'get should return the codec from the first source t..has one'() {

[MSG]Method "get should return the codec from the first source that has one" has a dynamic return type

[SRC]def minKeyCodec1 = new MinKeyCodec()

[MSG]The type is not specified for variable "minKeyCodec1"

[SRC]def minKeyCodec2 = new MinKeyCodec()

[MSG]The type is not specified for variable "minKeyCodec2"

[SRC]def registry = new ProvidersCodecRegistry([new SingleCod..KeyCodec2)])

[MSG]The type is not specified for variable "registry"

[SRC]def 'should handle cycles'() {

[MSG]Method "should handle cycles" has a dynamic return type

[SRC]def registry = new ProvidersCodecRegistry([new ClassMode..Provider()])

[MSG]The type is not specified for variable "registry"

[SRC]def top = new Top('Bob',

[MSG]The type is not specified for variable "top"

[SRC]def writer = new BsonBinaryWriter(new BasicOutputBuffer())

[MSG]The type is not specified for variable "writer"

[SRC]def 'get should use the codecCache'() {

[MSG]Method "get should use the codecCache" has a dynamic return type

[SRC]def provider = Mock(CodecProvider)

[MSG]The type is not specified for variable "provider"

[SRC]def registry = new ProvidersCodecRegistry([provider])

[MSG]The type is not specified for variable "registry"

[SRC]def 'get with codec registry should return the codec fro..has one'() {

[MSG]Method "get with codec registry should return the codec from the first source that has one" has a dynamic return type

[SRC]def provider = new ProvidersCodecRegistry([new ClassMode..([Simple])])

[MSG]The type is not specified for variable "provider"

[SRC]def registry = Mock(CodecRegistry)

[MSG]The type is not specified for variable "registry"

[SRC]def 'get with codec registry should return null if codec..t found'() {

[MSG]Method "get with codec registry should return null if codec not found" has a dynamic return type

[SRC]def provider = new ProvidersCodecRegistry([new ClassMode..der([Top])])

[MSG]The type is not specified for variable "provider"

[SRC]def registry = Mock(CodecRegistry)

[MSG]The type is not specified for variable "registry"

[SRC]def 'get with codec registry should pass the outer regis..oviders'() {

[MSG]Method "get with codec registry should pass the outer registry to its providers" has a dynamic return type

[SRC]def provider = new ProvidersCodecRegistry([new ClassMode..([Simple])])

[MSG]The type is not specified for variable "provider"

[SRC]def registry = Mock(CodecRegistry)

[MSG]The type is not specified for variable "registry"

[SRC]def name = reader.readString()

[MSG]The type is not specified for variable "name"

[SRC]def other = null

[MSG]The type is not specified for variable "other"

[SRC]def nested = null

[MSG]The type is not specified for variable "nested"

[SRC]def type = reader.readBsonType()

[MSG]The type is not specified for variable "type"

[SRC]def name = reader.readString()

[MSG]The type is not specified for variable "name"

[SRC]def type = reader.readBsonType()

[MSG]The type is not specified for variable "type"

[SRC]def top = null

[MSG]The type is not specified for variable "top"

[SRC]boolean equals(final o) {

[MSG]"o" parameter of "equals" method is dynamically typed

[SRC]boolean equals(final o) {

[MSG]"o" parameter of "equals" method is dynamically typed

[SRC]def 'position and size should be 0 after constructor'() {

[MSG]Method "position and size should be 0 after constructor" has a dynamic return type

[SRC]def bsonOutput = new BasicOutputBuffer()

[MSG]The type is not specified for variable "bsonOutput"

[SRC]def 'should write a byte'() {

[MSG]Method "should write a byte" has a dynamic return type

[SRC]def bsonOutput = new BasicOutputBuffer()

[MSG]The type is not specified for variable "bsonOutput"

[SRC]def 'should write bytes'() {

[MSG]Method "should write bytes" has a dynamic return type

[SRC]def bsonOutput = new BasicOutputBuffer()

[MSG]The type is not specified for variable "bsonOutput"

[SRC]def 'should write bytes from offset until length'() {

[MSG]Method "should write bytes from offset until length" has a dynamic return type

[SRC]def bsonOutput = new BasicOutputBuffer()

[MSG]The type is not specified for variable "bsonOutput"

[SRC]def 'should write a little endian Int32'() {

[MSG]Method "should write a little endian Int32" has a dynamic return type

[SRC]def bsonOutput = new BasicOutputBuffer()

[MSG]The type is not specified for variable "bsonOutput"

[SRC]def 'should write a little endian Int64'() {

[MSG]Method "should write a little endian Int64" has a dynamic return type

[SRC]def bsonOutput = new BasicOutputBuffer()

[MSG]The type is not specified for variable "bsonOutput"

[SRC]def 'should write a double'() {

[MSG]Method "should write a double" has a dynamic return type

[SRC]def bsonOutput = new BasicOutputBuffer()

[MSG]The type is not specified for variable "bsonOutput"

[SRC]def 'should write an ObjectId'() {

[MSG]Method "should write an ObjectId" has a dynamic return type

[SRC]def objectIdAsByteArray = [12, 11, 10, 9, 8, 7, 6, 5, 4,..1] as byte[]

[MSG]The type is not specified for variable "objectIdAsByteArray"

[SRC]def bsonOutput = new BasicOutputBuffer()

[MSG]The type is not specified for variable "bsonOutput"

[SRC]def 'should write an empty string'() {

[MSG]Method "should write an empty string" has a dynamic return type

[SRC]def bsonOutput = new BasicOutputBuffer()

[MSG]The type is not specified for variable "bsonOutput"

[SRC]def 'should write an ASCII string'() {

[MSG]Method "should write an ASCII string" has a dynamic return type

[SRC]def bsonOutput = new BasicOutputBuffer()

[MSG]The type is not specified for variable "bsonOutput"

[SRC]def 'should write a UTF-8 string'() {

[MSG]Method "should write a UTF-8 string" has a dynamic return type

[SRC]def bsonOutput = new BasicOutputBuffer()

[MSG]The type is not specified for variable "bsonOutput"

[SRC]def 'should write an empty CString'() {

[MSG]Method "should write an empty CString" has a dynamic return type

[SRC]def bsonOutput = new BasicOutputBuffer()

[MSG]The type is not specified for variable "bsonOutput"

[SRC]def 'should write an ASCII CString'() {

[MSG]Method "should write an ASCII CString" has a dynamic return type

[SRC]def bsonOutput = new BasicOutputBuffer()

[MSG]The type is not specified for variable "bsonOutput"

[SRC]def 'should write a UTF-8 CString'() {

[MSG]Method "should write a UTF-8 CString" has a dynamic return type

[SRC]def bsonOutput = new BasicOutputBuffer()

[MSG]The type is not specified for variable "bsonOutput"

[SRC]def 'null character in CString should throw Serializatio..ception'() {

[MSG]Method "null character in CString should throw SerializationException" has a dynamic return type

[SRC]def bsonOutput = new BasicOutputBuffer()

[MSG]The type is not specified for variable "bsonOutput"

[SRC]def 'null character in String should not throw Serializa..ception'() {

[MSG]Method "null character in String should not throw SerializationException" has a dynamic return type

[SRC]def bsonOutput = new BasicOutputBuffer()

[MSG]The type is not specified for variable "bsonOutput"

[SRC]def 'write Int32 at position should throw with invalid position'() {

[MSG]Method "write Int32 at position should throw with invalid position" has a dynamic return type

[SRC]def bsonOutput = new BasicOutputBuffer()

[MSG]The type is not specified for variable "bsonOutput"

[SRC]def 'should write Int32 at position'() {

[MSG]Method "should write Int32 at position" has a dynamic return type

[SRC]def bsonOutput = new BasicOutputBuffer()

[MSG]The type is not specified for variable "bsonOutput"

[SRC]def 'truncate should throw with invalid position'() {

[MSG]Method "truncate should throw with invalid position" has a dynamic return type

[SRC]def bsonOutput = new BasicOutputBuffer()

[MSG]The type is not specified for variable "bsonOutput"

[SRC]def 'should truncate to position'() {

[MSG]Method "should truncate to position" has a dynamic return type

[SRC]def bsonOutput = new BasicOutputBuffer()

[MSG]The type is not specified for variable "bsonOutput"

[SRC]def 'should grow'() {

[MSG]Method "should grow" has a dynamic return type

[SRC]def bsonOutput = new BasicOutputBuffer(4)

[MSG]The type is not specified for variable "bsonOutput"

[SRC]def 'should get byte buffer as little endian'() {

[MSG]Method "should get byte buffer as little endian" has a dynamic return type

[SRC]def bsonOutput = new BasicOutputBuffer(4)

[MSG]The type is not specified for variable "bsonOutput"

[SRC]def 'should get internal buffer'() {

[MSG]Method "should get internal buffer" has a dynamic return type

[SRC]def bsonOutput = new BasicOutputBuffer(4)

[MSG]The type is not specified for variable "bsonOutput"

[SRC]def 'should close'() {

[MSG]Method "should close" has a dynamic return type

[SRC]def bsonOutput = new BasicOutputBuffer()

[MSG]The type is not specified for variable "bsonOutput"

[SRC]def getBytes(final BasicOutputBuffer basicOutputBuffer) {

[MSG]Method "getBytes" has a dynamic return type

[SRC]def 'constructor should throw of buffer is null'() {

[MSG]Method "constructor should throw of buffer is null" has a dynamic return type

[SRC]def 'position should start at 0'() {

[MSG]Method "position should start at 0" has a dynamic return type

[SRC]def stream = new ByteBufferBsonInput(new ByteBufNIO(Byte..w byte[4])))

[MSG]The type is not specified for variable "stream"

[SRC]def 'should read a byte'() {

[MSG]Method "should read a byte" has a dynamic return type

[SRC]def stream = new ByteBufferBsonInput(new ByteBufNIO(Byte..as byte[])))

[MSG]The type is not specified for variable "stream"

[SRC]def 'should read into a byte array'() {

[MSG]Method "should read into a byte array" has a dynamic return type

[SRC]def bytes = [11, 12, 13] as byte[]

[MSG]The type is not specified for variable "bytes"

[SRC]def stream = new ByteBufferBsonInput(new ByteBufNIO(Byte..rap(bytes)))

[MSG]The type is not specified for variable "stream"

[SRC]def bytesRead = new byte[bytes.length]

[MSG]The type is not specified for variable "bytesRead"

[MSG]Code block ends with a blank line.

[SRC]def 'should read into a byte array at offset until length'() {

[MSG]Method "should read into a byte array at offset until length" has a dynamic return type

[SRC]def bytes = [11, 12, 13] as byte[]

[MSG]The type is not specified for variable "bytes"

[SRC]def stream = new ByteBufferBsonInput(new ByteBufNIO(Byte..rap(bytes)))

[MSG]The type is not specified for variable "stream"

[SRC]def bytesRead = new byte[bytes.length + 2]

[MSG]The type is not specified for variable "bytesRead"

[SRC]def 'should read a little endian Int32'() {

[MSG]Method "should read a little endian Int32" has a dynamic return type

[SRC]def stream = new ByteBufferBsonInput(new ByteBufNIO(Byte..as byte[])))

[MSG]The type is not specified for variable "stream"

[SRC]def 'should read a little endian Int64'() {

[MSG]Method "should read a little endian Int64" has a dynamic return type

[SRC]def stream = new ByteBufferBsonInput(new ByteBufNIO(Byte..as byte[])))

[MSG]The type is not specified for variable "stream"

[SRC]def 'should read a double'() {

[MSG]Method "should read a double" has a dynamic return type

[SRC]def stream = new ByteBufferBsonInput(new ByteBufNIO(Byte..as byte[])))

[MSG]The type is not specified for variable "stream"

[SRC]def 'should read ObjectId'() {

[MSG]Method "should read ObjectId" has a dynamic return type

[SRC]def objectIdAsByteArray = [12, 11, 10, 9, 8, 7, 6, 5, 4,..1] as byte[]

[MSG]The type is not specified for variable "objectIdAsByteArray"

[SRC]def stream = new ByteBufferBsonInput(new ByteBufNIO(Byte..ByteArray)))

[MSG]The type is not specified for variable "stream"

[SRC]def 'should read an empty string'() {

[MSG]Method "should read an empty string" has a dynamic return type

[SRC]def stream = new ByteBufferBsonInput(new ByteBufNIO(Byte..as byte[])))

[MSG]The type is not specified for variable "stream"

[SRC]def 'should read a one byte string'() {

[MSG]Method "should read a one byte string" has a dynamic return type

[SRC]def stream = new ByteBufferBsonInput(new ByteBufNIO(Byte..as byte[])))

[MSG]The type is not specified for variable "stream"

[SRC]def 'should read an invalid one byte string'() {

[MSG]Method "should read an invalid one byte string" has a dynamic return type

[SRC]def stream = new ByteBufferBsonInput(new ByteBufNIO(Byte..as byte[])))

[MSG]The type is not specified for variable "stream"

[SRC]def 'should read an ASCII string'() {

[MSG]Method "should read an ASCII string" has a dynamic return type

[SRC]def stream = new ByteBufferBsonInput(new ByteBufNIO(Byte..as byte[])))

[MSG]The type is not specified for variable "stream"

[SRC]def 'should read a UTF-8 string'() {

[MSG]Method "should read a UTF-8 string" has a dynamic return type

[SRC]def stream = new ByteBufferBsonInput(new ByteBufNIO(Byte..as byte[])))

[MSG]The type is not specified for variable "stream"

[SRC]def 'should read an empty CString'() {

[MSG]Method "should read an empty CString" has a dynamic return type

[SRC]def stream = new ByteBufferBsonInput(new ByteBufNIO(Byte..as byte[])))

[MSG]The type is not specified for variable "stream"

[SRC]def 'should read a one byte CString'() {

[MSG]Method "should read a one byte CString" has a dynamic return type

[SRC]def stream = new ByteBufferBsonInput(new ByteBufNIO(Byte..as byte[])))

[MSG]The type is not specified for variable "stream"

[SRC]def 'should read an invalid one byte CString'() {

[MSG]Method "should read an invalid one byte CString" has a dynamic return type

[SRC]def stream = new ByteBufferBsonInput(new ByteBufNIO(Byte..as byte[])))

[MSG]The type is not specified for variable "stream"

[SRC]def 'should read an ASCII CString'() {

[MSG]Method "should read an ASCII CString" has a dynamic return type

[SRC]def stream = new ByteBufferBsonInput(new ByteBufNIO(Byte..as byte[])))

[MSG]The type is not specified for variable "stream"

[SRC]def 'should read a UTF-8 CString'() {

[MSG]Method "should read a UTF-8 CString" has a dynamic return type

[SRC]def stream = new ByteBufferBsonInput(new ByteBufNIO(Byte..as byte[])))

[MSG]The type is not specified for variable "stream"

[SRC]def 'should read from position'() {

[MSG]Method "should read from position" has a dynamic return type

[SRC]def stream = new ByteBufferBsonInput(new ByteBufNIO(Byte..as byte[])))

[MSG]The type is not specified for variable "stream"

[SRC]def 'should skip CString'() {

[MSG]Method "should skip CString" has a dynamic return type

[SRC]def stream = new ByteBufferBsonInput(new ByteBufNIO(Byte..as byte[])))

[MSG]The type is not specified for variable "stream"

[SRC]def 'should skip'() {

[MSG]Method "should skip" has a dynamic return type

[SRC]def stream = new ByteBufferBsonInput(new ByteBufNIO(Byte..as byte[])))

[MSG]The type is not specified for variable "stream"

[SRC]def 'reset should throw when there is no mark'() {

[MSG]Method "reset should throw when there is no mark" has a dynamic return type

[SRC]def stream = new ByteBufferBsonInput(new ByteBufNIO(Byte..as byte[])))

[MSG]The type is not specified for variable "stream"

[SRC]def 'should reset to the mark'() {

[MSG]Method "should reset to the mark" has a dynamic return type

[SRC]def stream = new ByteBufferBsonInput(new ByteBufNIO(Byte..as byte[])))

[MSG]The type is not specified for variable "stream"

[SRC]def 'should have remaining when there are more bytes'() {

[MSG]Method "should have remaining when there are more bytes" has a dynamic return type

[SRC]def stream = new ByteBufferBsonInput(new ByteBufNIO(Byte..as byte[])))

[MSG]The type is not specified for variable "stream"

[SRC]def 'should not have remaining when there are no more bytes'() {

[MSG]Method "should not have remaining when there are no more bytes" has a dynamic return type

[SRC]def stream = new ByteBufferBsonInput(new ByteBufNIO(Byte..as byte[])))

[MSG]The type is not specified for variable "stream"

[SRC]def 'should close the stream'() {

[MSG]Method "should close the stream" has a dynamic return type

[SRC]def stream = new ByteBufferBsonInput(new ByteBufNIO(Byte..as byte[])))

[MSG]The type is not specified for variable "stream"

[SRC]def 'should throw BsonSerializationException reading a b..ailable'() {

[MSG]Method "should throw BsonSerializationException reading a byte if no byte is available" has a dynamic return type

[SRC]def stream = new ByteBufferBsonInput(new ByteBufNIO(Byte..as byte[])))

[MSG]The type is not specified for variable "stream"

[SRC]def 'should throw BsonSerializationException reading an ..ailable'() {

[MSG]Method "should throw BsonSerializationException reading an Int32 if less than 4 bytes are available" has a dynamic return type

[SRC]def stream = new ByteBufferBsonInput(new ByteBufNIO(Byte..as byte[])))

[MSG]The type is not specified for variable "stream"

[SRC]def 'should throw BsonSerializationException reading an ..ailable'() {

[MSG]Method "should throw BsonSerializationException reading an Int64 if less than 8 bytes are available" has a dynamic return type

[SRC]def stream = new ByteBufferBsonInput(new ByteBufNIO(Byte..as byte[])))

[MSG]The type is not specified for variable "stream"

[SRC]def 'should throw BsonSerializationException reading a d..ailable'() {

[MSG]Method "should throw BsonSerializationException reading a double if less than 8 bytes are available" has a dynamic return type

[SRC]def stream = new ByteBufferBsonInput(new ByteBufNIO(Byte..as byte[])))

[MSG]The type is not specified for variable "stream"

[SRC]def 'should throw BsonSerializationException reading an ..ailable'() {

[MSG]Method "should throw BsonSerializationException reading an ObjectId if less than 12 bytes are available" has a dynamic return type

[SRC]def stream = new ByteBufferBsonInput(new ByteBufNIO(Byte..as byte[])))

[MSG]The type is not specified for variable "stream"

[SRC]def 'should throw BsonSerializationException reading int..ailable'() {

[MSG]Method "should throw BsonSerializationException reading into a byte array if not enough bytes are available" has a dynamic return type

[SRC]def stream = new ByteBufferBsonInput(new ByteBufNIO(Byte..as byte[])))

[MSG]The type is not specified for variable "stream"

[SRC]def 'should throw BsonSerializationException reading par..ailable'() {

[MSG]Method "should throw BsonSerializationException reading partially into a byte array if not enough bytes are available" has a dynamic return type

[SRC]def stream = new ByteBufferBsonInput(new ByteBufNIO(Byte..as byte[])))

[MSG]The type is not specified for variable "stream"

[SRC]def 'should throw BsonSerializationException if the leng..ositive'() {

[MSG]Method "should throw BsonSerializationException if the length of a BSON string is not positive" has a dynamic return type

[SRC]def stream = new ByteBufferBsonInput(new ByteBufNIO(Byte..as byte[])))

[MSG]The type is not specified for variable "stream"

[SRC]def 'should throw BsonSerializationException if a BSON s..minated'() {

[MSG]Method "should throw BsonSerializationException if a BSON string is not null-terminated" has a dynamic return type

[SRC]def stream = new ByteBufferBsonInput(new ByteBufNIO(Byte..as byte[])))

[MSG]The type is not specified for variable "stream"

[SRC]def 'should throw BsonSerializationException if a one-by..minated'() {

[MSG]Method "should throw BsonSerializationException if a one-byte BSON string is not null-terminated" has a dynamic return type

[SRC]def stream = new ByteBufferBsonInput(new ByteBufNIO(Byte..as byte[])))

[MSG]The type is not specified for variable "stream"

[SRC]def 'encodes #encoded into #decoded'() {

[MSG]Method "encodes #encoded into #decoded" has a dynamic return type

[SRC]def 'should skip value #value'() {

[MSG]Method "should skip value #value" has a dynamic return type

[SRC]def document = new BsonDocument('name', value)

[MSG]The type is not specified for variable "document"

[SRC]def reader = new JsonReader(document.toJson())

[MSG]The type is not specified for variable "reader"

[SRC]def 'test defaults'() {

[MSG]Method "test defaults" has a dynamic return type

[SRC]def settings = new JsonWriterSettings();

[MSG]The type is not specified for variable "settings"

[SRC]def 'test output mode'() {

[MSG]Method "test output mode" has a dynamic return type

[SRC]def settings = JsonWriterSettings.builder().outputMode(J..ELL).build()

[MSG]The type is not specified for variable "settings"

[SRC]def 'test indent defaults'() {

[MSG]Method "test indent defaults" has a dynamic return type

[SRC]def settings = JsonWriterSettings.builder().indent(true).build()

[MSG]The type is not specified for variable "settings"

[SRC]def 'test indent settings'() {

[MSG]Method "test indent settings" has a dynamic return type

[SRC]def settings = JsonWriterSettings.builder()

[MSG]The type is not specified for variable "settings"

[SRC]def 'test max length setting'() {

[MSG]Method "test max length setting" has a dynamic return type

[SRC]def settings = JsonWriterSettings.builder()

[MSG]The type is not specified for variable "settings"

[SRC]def 'test constructors'() {

[MSG]Method "test constructors" has a dynamic return type

[SRC]def settings = new JsonWriterSettings()

[MSG]The type is not specified for variable "settings"

[MSG]Code block ends with a blank line.

[SRC]def 'should use legacy extended json converters for strict mode'() {

[MSG]Method "should use legacy extended json converters for strict mode" has a dynamic return type

[SRC]def settings = JsonWriterSettings.builder().outputMode(J..ICT).build()

[MSG]The type is not specified for variable "settings"

[SRC]def 'should use extended json converters for extended json mode'() {

[MSG]Method "should use extended json converters for extended json mode" has a dynamic return type

[SRC]def settings = JsonWriterSettings.builder().outputMode(J..DED).build()

[MSG]The type is not specified for variable "settings"

[SRC]def 'should use shell converters for shell mode'() {

[MSG]Method "should use shell converters for shell mode" has a dynamic return type

[SRC]def settings = JsonWriterSettings.builder().outputMode(J..ELL).build()

[MSG]The type is not specified for variable "settings"

[SRC]def 'should set converters'() {

[MSG]Method "should set converters" has a dynamic return type

[SRC]def binaryConverter = new ShellBinaryConverter()

[MSG]The type is not specified for variable "binaryConverter"

[SRC]def booleanConverter = new JsonBooleanConverter()

[MSG]The type is not specified for variable "booleanConverter"

[SRC]def dateTimeConverter = new ShellDateTimeConverter()

[MSG]The type is not specified for variable "dateTimeConverter"

[SRC]def decimal128Converter = new ShellDecimal128Converter()

[MSG]The type is not specified for variable "decimal128Converter"

[SRC]def doubleConverter = new JsonDoubleConverter()

[MSG]The type is not specified for variable "doubleConverter"

[SRC]def int32Converter = new JsonInt32Converter()

[MSG]The type is not specified for variable "int32Converter"

[SRC]def int64Converter = new ShellInt64Converter()

[MSG]The type is not specified for variable "int64Converter"

[SRC]def javaScriptConverter = new JsonJavaScriptConverter()

[MSG]The type is not specified for variable "javaScriptConverter"

[SRC]def maxKeyConverter = new ShellMaxKeyConverter()

[MSG]The type is not specified for variable "maxKeyConverter"

[SRC]def minKeyConverter = new ShellMinKeyConverter()

[MSG]The type is not specified for variable "minKeyConverter"

[SRC]def nullConverter = new JsonNullConverter()

[MSG]The type is not specified for variable "nullConverter"

[SRC]def objectIdConverter = new ShellObjectIdConverter()

[MSG]The type is not specified for variable "objectIdConverter"

[SRC]def regularExpressionConverter = new ShellRegularExpressionConverter()

[MSG]The type is not specified for variable "regularExpressionConverter"

[SRC]def stringConverter = new JsonStringConverter()

[MSG]The type is not specified for variable "stringConverter"

[SRC]def symbolConverter = new JsonSymbolConverter()

[MSG]The type is not specified for variable "symbolConverter"

[SRC]def timestampConverter = new ShellTimestampConverter()

[MSG]The type is not specified for variable "timestampConverter"

[SRC]def undefinedConverter = new ShellUndefinedConverter()

[MSG]The type is not specified for variable "undefinedConverter"

[SRC]def settings = JsonWriterSettings.builder()

[MSG]The type is not specified for variable "settings"

[SRC]def stringWriter = new StringWriter();

[MSG]The type is not specified for field "stringWriter"

[SRC]def writer = new JsonWriter(stringWriter)

[MSG]The type is not specified for field "writer"

[SRC]def jsonWithValuesOfEveryType = documentWithValuesOfEver..r().build())

[MSG]The type is not specified for field "jsonWithValuesOfEveryType"

[SRC]def 'should pipe all types'() {

[MSG]Method "should pipe all types" has a dynamic return type

[SRC]def reader = new BsonDocumentReader(documentWithValuesOfEveryType())

[MSG]The type is not specified for variable "reader"

[SRC]def 'should pipe all types with capped length'() {

[MSG]Method "should pipe all types with capped length" has a dynamic return type

[SRC]def reader = new BsonDocumentReader(documentWithValuesOfEveryType())

[MSG]The type is not specified for variable "reader"

[SRC]def writer = new JsonWriter(stringWriter, JsonWriterSett..th).build())

[MSG]The type is not specified for variable "writer"

[SRC]def shouldThrowAnExceptionWhenWritingNullName() {

[MSG]Method "shouldThrowAnExceptionWhenWritingNullName" has a dynamic return type

[SRC]def shouldThrowAnExceptionWhenWritingNullValue() {

[MSG]Method "shouldThrowAnExceptionWhenWritingNullValue" has a dynamic return type

[SRC]def shouldThrowAnExceptionWhenWritingNullMemberValue() {

[MSG]Method "shouldThrowAnExceptionWhenWritingNullMemberValue" has a dynamic return type

[SRC]def shouldThrowAnExceptionWhenWritingNullMemberName() {

[MSG]Method "shouldThrowAnExceptionWhenWritingNullMemberName" has a dynamic return type

[SRC]def setup() {

[MSG]Method "setup" has a dynamic return type

[SRC]def 'should write empty document'() {

[MSG]Method "should write empty document" has a dynamic return type

[SRC]def 'should write empty array'() {

[MSG]Method "should write empty array" has a dynamic return type

[SRC]def 'should write null'() {

[MSG]Method "should write null" has a dynamic return type

[SRC]def 'should write boolean'() {

[MSG]Method "should write boolean" has a dynamic return type

[SRC]def 'should write number'() {

[MSG]Method "should write number" has a dynamic return type

[SRC]def 'should write string'() {

[MSG]Method "should write string" has a dynamic return type

[SRC]def 'should write unquoted string'() {

[MSG]Method "should write unquoted string" has a dynamic return type

[SRC]def 'should write document'() {

[MSG]Method "should write document" has a dynamic return type

[SRC]def 'should write array'() {

[MSG]Method "should write array" has a dynamic return type

[SRC]def 'should write array of values'() {

[MSG]Method "should write array of values" has a dynamic return type

[SRC]def 'should write strings'() {

[MSG]Method "should write strings" has a dynamic return type

[SRC]'abc\u0000def' | '"abc\\u0000def"'

[MSG]The statement on line 156 in class org.bson.json.StrictCharacterStreamJsonWriterSpecification is at the incorrect indent level: Expected column 9 but was 14

[SRC]'\u0080' | '"\\u0080"'

[MSG]The statement on line 166 in class org.bson.json.StrictCharacterStreamJsonWriterSpecification is at the incorrect indent level: Expected column 9 but was 14

[SRC]'\u0080\u0081' | '"\\u0080\\u0081"'

[MSG]The statement on line 167 in class org.bson.json.StrictCharacterStreamJsonWriterSpecification is at the incorrect indent level: Expected column 9 but was 19

[SRC]'\u0080\u0081\u0082' | '"\\u0080\\u0081\\u0082"'

[MSG]The statement on line 168 in class org.bson.json.StrictCharacterStreamJsonWriterSpecification is at the incorrect indent level: Expected column 9 but was 24

[SRC]def 'should indent one element'() {

[MSG]Method "should indent one element" has a dynamic return type

[SRC]def 'should indent one element with indent and newline characters'() {

[MSG]Method "should indent one element with indent and newline characters" has a dynamic return type

[SRC]def 'should indent two elements'() {

[MSG]Method "should indent two elements" has a dynamic return type

[SRC]def 'should indent embedded document'() {

[MSG]Method "should indent embedded document" has a dynamic return type

[SRC]def shouldThrowExceptionForBooleanWhenWritingBeforeStart..Document() {

[MSG]Method "shouldThrowExceptionForBooleanWhenWritingBeforeStartingDocument" has a dynamic return type

[SRC]def shouldThrowExceptionForNameWhenWritingBeforeStartingDocument() {

[MSG]Method "shouldThrowExceptionForNameWhenWritingBeforeStartingDocument" has a dynamic return type

[SRC]def shouldThrowExceptionForStringWhenStateIsValue() {

[MSG]Method "shouldThrowExceptionForStringWhenStateIsValue" has a dynamic return type

[SRC]def shouldThrowExceptionWhenEndingAnArrayWhenStateIsValue() {

[MSG]Method "shouldThrowExceptionWhenEndingAnArrayWhenStateIsValue" has a dynamic return type

[SRC]def shouldThrowExceptionWhenWritingASecondName() {

[MSG]Method "shouldThrowExceptionWhenWritingASecondName" has a dynamic return type

[SRC]def shouldThrowExceptionWhenEndingADocumentBeforeValueIsWritten() {

[MSG]Method "shouldThrowExceptionWhenEndingADocumentBeforeValueIsWritten" has a dynamic return type