     func testPredicate1() {
         
         let predicate: Predicate = #keyPath(PersonObject.id) > Int64(0)
-            && #keyPath(PersonObject.id) != Int64(99)
+            && (#keyPath(PersonObject.name)).compare(.notEqualTo, .value(.null))
+            && (#keyPath(PersonObject.id)) != Int64(99)
+            && (#keyPath(PersonObject.id)) == Int64(1)
             && (#keyPath(PersonObject.name)).compare(.beginsWith, .value(.string("C")))
             && (#keyPath(PersonObject.name)).compare(.contains, [.diacriticInsensitive, .caseInsensitive], .value(.string("COLE")))
         

        print(predicate)
        print(converted)
        
        XCTAssert(predicate.description == converted.description, "Invalid description")
        XCTAssert(converted.evaluate(with: PersonObject(id: 1, name: "Coléman")))
    }
    

        
        XCTAssertEqual((events as NSArray).filtered(using: nsPredicate).count, events.count)
    }
    
    func testPredicate8() {
        
        let attributes = AttributesObject()
        attributes.numbers = [0,1,2,3]
        attributes.strings = ["1", "2", "3"]
        
        let predicate: Predicate = (#keyPath(AttributesObject.string)).compare(.equalTo, .value(.null))
            //&& (#keyPath(AttributesObject.numbers)).compare(.contains, .value(.int8(1)))
            && (#keyPath(AttributesObject.strings)).compare(.contains, .value(.string("1")))
            //&& (#keyPath(AttributesObject.numbers)).compare(.contains, .value(.collection([.int8(1)])))
            //&& (#keyPath(AttributesObject.strings)).compare(.contains, .value(.collection([.string("1")])))
        
        let nsPredicate = predicate.toFoundation()
        
        print(predicate)
        print(nsPredicate)
        
        XCTAssertEqual(predicate.description, nsPredicate.description, "Invalid description")
        XCTAssert(try attributes.evaluate(with: predicate))
    }
}

// MARK: - Supporting Types
