diff --git a/templates/dart/test/query_test.dart.twig b/templates/dart/test/query_test.dart.twig
index cbe838079..106262c10 100644
--- a/templates/dart/test/query_test.dart.twig
+++ b/templates/dart/test/query_test.dart.twig
@@ -1,3 +1,5 @@
+import 'dart:convert';
+
 import 'package:{{ language.params.packageName }}/{{ language.params.packageName }}.dart';
 {% if 'dart' in language.params.packageName %}
 import 'package:test/test.dart';
@@ -5,10 +7,10 @@ import 'package:test/test.dart';
 import 'package:flutter_test/flutter_test.dart';
 {% endif %}
 
-class BasicFilterQueryTest {
+class BasicFilterQueryTest<V, E> {
   final String description;
-  final dynamic value;
-  final String expectedValues;
+  final V value;
+  final E expectedValues;
 
   BasicFilterQueryTest({
     required this.description,
@@ -20,42 +22,42 @@ class BasicFilterQueryTest {
 void main() {
   group('basic filter tests', () {
     final tests = [
-      BasicFilterQueryTest(
+      BasicFilterQueryTest<String, List<String>>(
         description: 'with a string',
         value: 's',
-        expectedValues: ["s"],
+        expectedValues: ['s'],
       ),
-      BasicFilterQueryTest(
+      BasicFilterQueryTest<int, List<int>>(
         description: 'with an integer',
         value: 1,
         expectedValues: [1],
       ),
-      BasicFilterQueryTest(
+      BasicFilterQueryTest<double, List<double>>(
         description: 'with a double',
         value: 1.2,
         expectedValues: [1.2],
       ),
-      BasicFilterQueryTest(
+      BasicFilterQueryTest<double, List<double>>(
         description: 'with a whole number double',
         value: 1.0,
         expectedValues: [1.0],
       ),
-      BasicFilterQueryTest(
+      BasicFilterQueryTest<bool, List<bool>>(
         description: 'with a bool',
         value: false,
         expectedValues: [false],
       ),
-      BasicFilterQueryTest(
+      BasicFilterQueryTest<List<String>, List<String>>(
         description: 'with a list',
         value: ['a', 'b', 'c'],
-        expectedValues: ["a","b","c"],
+        expectedValues: ['a', 'b', 'c'],
       ),
     ];
 
     group('equal()', () {
       for (var t in tests) {
         test(t.description, () {
-          final query = Query.equal('attr', t.value).toJson();
+          final query = jsonDecode(Query.equal('attr', t.value));
           expect(query['attribute'], 'attr');
           expect(query['values'], t.expectedValues);
           expect(query['method'], 'equal');
@@ -66,75 +68,115 @@ void main() {
     group('notEqual()', () {
       for (var t in tests) {
         test(t.description, () {
-          final query = Query.notEqual('attr', t.value).toJson();
+          final query = jsonDecode(Query.notEqual('attr', t.value));
           expect(query['attribute'], 'attr');
           expect(query['values'], t.expectedValues);
           expect(query['method'], 'notEqual');
         });
       }
+
+      test('with a list', () {
+        final query = jsonDecode(Query.notEqual('attr', ['a', 'b', 'c']));
+        print(query);
+        expect(query['attribute'], 'attr');
+        expect(query['values'], [['a', 'b', 'c']]); // Is there a bug here?
+        expect(query['method'], 'notEqual');
+      });
     });
 
     group('lessThan()', () {
       for (var t in tests) {
         test(t.description, () {
-          final query = Query.lessThan('attr', t.value).toJson();
+          final query = jsonDecode(Query.lessThan('attr', t.value));
           expect(query['attribute'], 'attr');
           expect(query['values'], t.expectedValues);
           expect(query['method'], 'lessThan');
         });
       }
+
+      test('with a list', () {
+        final query = jsonDecode(Query.lessThan('attr', ['a', 'b', 'c']));
+        print(query);
+        expect(query['attribute'], 'attr');
+        expect(query['values'], ['a', 'b', 'c']);
+        expect(query['method'], 'lessThan');
+      });
     });
 
     group('lessThanEqual()', () {
       for (var t in tests) {
         test(t.description, () {
-          final query = Query.lessThanEqual('attr', t.value).toJson();
+          final query = jsonDecode(Query.lessThanEqual('attr', t.value));
           expect(query['attribute'], 'attr');
           expect(query['values'], t.expectedValues);
           expect(query['method'], 'lessThanEqual');
         });
       }
+
+      test('with a list', () {
+        final query = jsonDecode(Query.lessThanEqual('attr', ['a', 'b', 'c']));
+        print(query);
+        expect(query['attribute'], 'attr');
+        expect(query['values'], ['a', 'b', 'c']);
+        expect(query['method'], 'lessThanEqual');
+      });
     });
 
     group('greaterThan()', () {
       for (var t in tests) {
         test(t.description, () {
-          final query = Query.greaterThan('attr', t.value).toJson();
+          final query = jsonDecode(Query.greaterThan('attr', t.value));
           expect(query['attribute'], 'attr');
           expect(query['values'], t.expectedValues);
           expect(query['method'], 'greaterThan');
         });
       }
+
+      test('with a list', () {
+        final query = jsonDecode(Query.greaterThan('attr', ['a', 'b', 'c']));
+        print(query);
+        expect(query['attribute'], 'attr');
+        expect(query['values'], ['a', 'b', 'c']);
+        expect(query['method'], 'greaterThan');
+      });
     });
 
     group('greaterThanEqual()', () {
       for (var t in tests) {
         test(t.description, () {
-          final query = Query.greaterThanEqual('attr', t.value).toJson();
+          final query = jsonDecode(Query.greaterThanEqual('attr', t.value));
           expect(query['attribute'], 'attr');
           expect(query['values'], t.expectedValues);
           expect(query['method'], 'greaterThanEqual');
         });
       }
+
+      test('with a list', () {
+        final query = jsonDecode(Query.greaterThanEqual('attr', ['a', 'b', 'c']));
+        print(query);
+        expect(query['attribute'], 'attr');
+        expect(query['values'], ['a', 'b', 'c']);
+        expect(query['method'], 'greaterThanEqual');
+      });
     });
   });
 
   test('returns search', () {
-    final query = Query.search('attr', 'keyword1 keyword2').toJson();
+    final query = jsonDecode(Query.search('attr', 'keyword1 keyword2'));
     expect(query['attribute'], 'attr');
     expect(query['values'], ['keyword1 keyword2']);
     expect(query['method'], 'search');
   });
 
   test('returns isNull', () {
-    final query = Query.isNull('attr').toJson();
+    final query = jsonDecode(Query.isNull('attr'));
     expect(query['attribute'], 'attr');
     expect(query['values'], null);
     expect(query['method'], 'isNull');
   });
 
   test('returns isNotNull', () {
-    final query = Query.isNotNull('attr', 'keyword1 keyword2').toJson();
+    final query = jsonDecode(Query.isNotNull('attr'));
     expect(query['attribute'], 'attr');
     expect(query['values'], null);
     expect(query['method'], 'isNotNull');
@@ -142,21 +184,21 @@ void main() {
 
   group('between()', () {
     test('with integers', () {
-      final query = Query.between('attr', 1, 2).toJson();
+      final query = jsonDecode(Query.between('attr', 1, 2));
       expect(query['attribute'], 'attr');
       expect(query['values'], [1, 2]);
       expect(query['method'], 'between');
     });
 
     test('with doubles', () {
-      final query = Query.between('attr', 1.0, 2.0).toJson();
+      final query = jsonDecode(Query.between('attr', 1.0, 2.0));
       expect(query['attribute'], 'attr');
       expect(query['values'], [1.0, 2.0]);
       expect(query['method'], 'between');
     });
 
     test('with strings', () {
-      final query = Query.between('attr', 'a', 'z').toJson();
+      final query = jsonDecode(Query.between('attr', 'a', 'z'));
       expect(query['attribute'], 'attr');
       expect(query['values'], ['a', 'z']);
       expect(query['method'], 'between');
@@ -164,51 +206,51 @@ void main() {
   });
 
   test('returns select', () {
-    final query = Query.select(['attr1', 'attr2']).toJson();
+    final query = jsonDecode(Query.select(['attr1', 'attr2']));
     expect(query['attribute'], null);
     expect(query['values'], ['attr1', 'attr2']);
     expect(query['method'], 'select');
   });
 
   test('returns orderAsc', () {
-    final query = Query.orderAsc('attr').toJson();
+    final query = jsonDecode(Query.orderAsc('attr'));
     expect(query['attribute'], 'attr');
     expect(query['values'], null);
     expect(query['method'], 'orderAsc');
   });
 
   test('returns orderDesc', () {
-    final query = Query.orderDesc('attr').toJson();
+    final query = jsonDecode(Query.orderDesc('attr'));
     expect(query['attribute'], 'attr');
     expect(query['values'], null);
     expect(query['method'], 'orderDesc');
   });
 
   test('returns cursorBefore', () {
-    final query = Query.cursorBefore('custom').toJson();
+    final query = jsonDecode(Query.cursorBefore('custom'));
     expect(query['attribute'], null);
-    expect(query['values'], 'custom');
+    expect(query['values'], ['custom']);
     expect(query['method'], 'cursorBefore');
   });
 
   test('returns cursorAfter', () {
-    final query = Query.cursorAfter('custom').toJson();
+    final query = jsonDecode(Query.cursorAfter('custom'));
     expect(query['attribute'], null);
-    expect(query['values'], 'custom');
+    expect(query['values'], ['custom']);
     expect(query['method'], 'cursorAfter');
   });
 
   test('returns limit', () {
-    final query = Query.limit(1).toJson();
+    final query = jsonDecode(Query.limit(1));
     expect(query['attribute'], null);
-    expect(query['values'], 1);
+    expect(query['values'], [1]);
     expect(query['method'], 'limit');
   });
 
   test('returns offset', () {
-    final query = Query.offset(1).toJson();
+    final query = jsonDecode(Query.offset(1));
     expect(query['attribute'], null);
-    expect(query['values'], 1);
+    expect(query['values'], [1]);
     expect(query['method'], 'offset');
   });
 }