Improve collection assertions

client/trino-jdbc/src/test/java/io/trino/jdbc/TestJdbcWarnings.java

@@ -168,7 +168,7 @@ public void testExecuteQueryWarnings()
             TestingWarningCollector warningCollector = new TestingWarningCollector(new WarningCollectorConfig(), warningCollectorConfig);
             List<TrinoWarning> expectedWarnings = warningCollector.getWarnings();
             for (TrinoWarning trinoWarning : expectedWarnings) {
-                assertThat(currentWarnings.contains(new WarningEntry(toTrinoSqlWarning(trinoWarning)))).isTrue();
+                assertThat(currentWarnings).contains(new WarningEntry(toTrinoSqlWarning(trinoWarning)));
             }
         }
     }

core/trino-main/src/test/java/io/trino/block/TestMapBlock.java

@@ -337,8 +337,7 @@ private void assertValue(Block mapBlock, int position, Map<String, Long> map)
             else {
                 actualValue = BIGINT.getLong(rawValueBlock, rawOffset + i);
             }
-            assertThat(map.containsKey(actualKey)).isTrue();
-            assertThat(actualValue).isEqualTo(map.get(actualKey));
+            assertThat(map).containsEntry(actualKey, actualValue);
         }
     }
 

core/trino-main/src/test/java/io/trino/execution/TestNodeScheduler.java

@@ -311,7 +311,7 @@ public void testBasicAssignment()
         Multimap<InternalNode, Split> assignments = nodeSelector.computeAssignments(splits, ImmutableList.copyOf(taskMap.values())).getAssignments();
         assertThat(assignments.entries().size()).isEqualTo(assignments.size());
         for (InternalNode node : activeCatalogNodes) {
-            assertThat(assignments.keySet().contains(node)).isTrue();
+            assertThat(assignments.keySet()).contains(node);
         }
     }
 
@@ -370,7 +370,7 @@ public void testBasicAssignmentMaxUnacknowledgedSplitsPerTask()
         Multimap<InternalNode, Split> assignments = nodeSelector.computeAssignments(splits, ImmutableList.copyOf(taskMap.values())).getAssignments();
         assertThat(assignments.entries().size()).isEqualTo(activeCatalogNodes.size());
         for (InternalNode node : activeCatalogNodes) {
-            assertThat(assignments.keySet().contains(node)).isTrue();
+            assertThat(assignments.keySet()).contains(node);
         }
     }
 
@@ -492,7 +492,7 @@ public void testPrioritizedAssignmentOfLocalSplit()
         // Check that all splits are being assigned to node1
         assertThat(initialAssignment.size()).isEqualTo(20);
         assertThat(initialAssignment.keySet().size()).isEqualTo(1);
-        assertThat(initialAssignment.keySet().contains(node)).isTrue();
+        assertThat(initialAssignment.keySet()).contains(node);
 
         // Check for assignment of splits beyond maxSplitsPerNode (2 splits should remain unassigned)
         // 1 split with node1 as local node
@@ -504,7 +504,7 @@ public void testPrioritizedAssignmentOfLocalSplit()
         // Check that only 20 splits are being assigned as there is a single task
         assertThat(finalAssignment.size()).isEqualTo(20);
         assertThat(finalAssignment.keySet().size()).isEqualTo(1);
-        assertThat(finalAssignment.keySet().contains(node)).isTrue();
+        assertThat(finalAssignment.keySet()).contains(node);
 
         // When optimized-local-scheduling is enabled, the split with node1 as local node should be assigned
         long countLocalSplits = finalAssignment.values().stream()
@@ -535,7 +535,7 @@ public void testAssignmentWhenMixedSplits()
         // Check that all splits are being assigned to node1
         assertThat(initialAssignment.size()).isEqualTo(20);
         assertThat(initialAssignment.keySet().size()).isEqualTo(1);
-        assertThat(initialAssignment.keySet().contains(node)).isTrue();
+        assertThat(initialAssignment.keySet()).contains(node);
 
         // Check for assignment of splits beyond maxSplitsPerNode (2 splits should remain unassigned)
         // 1 split with node1 as local node
@@ -547,7 +547,7 @@ public void testAssignmentWhenMixedSplits()
         // Check that only 20 splits are being assigned as there is a single task
         assertThat(finalAssignment.size()).isEqualTo(20);
         assertThat(finalAssignment.keySet().size()).isEqualTo(1);
-        assertThat(finalAssignment.keySet().contains(node)).isTrue();
+        assertThat(finalAssignment.keySet()).contains(node);
 
         // When optimized-local-scheduling is enabled, all 11 splits with node1 as local node should be assigned
         long countLocalSplits = finalAssignment.values().stream()
@@ -575,8 +575,8 @@ public void testOptimizedLocalScheduling()
         // Check that all 20 splits are being assigned to node1 as optimized-local-scheduling is enabled
         assertThat(assignments1.size()).isEqualTo(20);
         assertThat(assignments1.keySet().size()).isEqualTo(2);
-        assertThat(assignments1.keySet().contains(node1)).isTrue();
-        assertThat(assignments1.keySet().contains(node2)).isTrue();
+        assertThat(assignments1.keySet()).contains(node1);
+        assertThat(assignments1.keySet()).contains(node2);
 
         // 19 splits with node2 as local node to be assigned in the first iteration of computeAssignments
         for (int i = 0; i < 19; i++) {
@@ -586,8 +586,8 @@ public void testOptimizedLocalScheduling()
         // Check that all 39 splits are being assigned (20 splits assigned to node1 and 19 splits assigned to node2)
         assertThat(assignments2.size()).isEqualTo(39);
         assertThat(assignments2.keySet().size()).isEqualTo(2);
-        assertThat(assignments2.keySet().contains(node1)).isTrue();
-        assertThat(assignments2.keySet().contains(node2)).isTrue();
+        assertThat(assignments2.keySet()).contains(node1);
+        assertThat(assignments2.keySet()).contains(node2);
 
         long node1Splits = assignments2.values().stream()
                 .map(Split::getConnectorSplit)
@@ -610,8 +610,8 @@ public void testOptimizedLocalScheduling()
         // Check that only 40 splits are being assigned as there is a single task
         assertThat(assignments3.size()).isEqualTo(40);
         assertThat(assignments3.keySet().size()).isEqualTo(2);
-        assertThat(assignments3.keySet().contains(node1)).isTrue();
-        assertThat(assignments3.keySet().contains(node2)).isTrue();
+        assertThat(assignments3.keySet()).contains(node1);
+        assertThat(assignments3.keySet()).contains(node2);
 
         // The first 20 splits have node1 as local, the next 19 have node2 as local, the 40th split has node1 as local and the 41st has node2 as local
         // If optimized-local-scheduling is disabled, the 41st split will be unassigned (the last slot in node2 will be taken up by the 40th split with node1 as local)
@@ -856,7 +856,7 @@ public void testMaxUnacknowledgedSplitsPerTask()
         // Attempt to schedule again, only the node with the unblocked task should be chosen
         splitPlacements = nodeSelector.computeAssignments(splits, ImmutableList.copyOf(tasks));
         assertThat(splitPlacements.getAssignments().size()).isEqualTo(1);
-        assertThat(splitPlacements.getAssignments().keySet().contains(nodes.get(0))).isTrue();
+        assertThat(splitPlacements.getAssignments().keySet()).contains(nodes.get(0));
 
         // Make the first node appear to have no splits, unacknowledged splits alone should force the splits to be spread across nodes
         taskOne.clearSplits();

core/trino-main/src/test/java/io/trino/execution/TestSetTimeZoneTask.java

@@ -103,7 +103,7 @@ public void testSetTimeZoneStringLiteral()
 
         Map<String, String> setSessionProperties = stateMachine.getSetSessionProperties();
         assertThat(setSessionProperties).hasSize(1);
-        assertThat(setSessionProperties.get(TIME_ZONE_ID)).isEqualTo("America/Los_Angeles");
+        assertThat(setSessionProperties).containsEntry(TIME_ZONE_ID, "America/Los_Angeles");
     }
 
     @Test
@@ -129,7 +129,7 @@ public void testSetTimeZoneVarcharFunctionCall()
 
         Map<String, String> setSessionProperties = stateMachine.getSetSessionProperties();
         assertThat(setSessionProperties).hasSize(1);
-        assertThat(setSessionProperties.get(TIME_ZONE_ID)).isEqualTo("America/Los_Angeles");
+        assertThat(setSessionProperties).containsEntry(TIME_ZONE_ID, "America/Los_Angeles");
     }
 
     @Test
@@ -170,7 +170,7 @@ public void testSetTimeZoneIntervalLiteral()
 
         Map<String, String> setSessionProperties = stateMachine.getSetSessionProperties();
         assertThat(setSessionProperties).hasSize(1);
-        assertThat(setSessionProperties.get(TIME_ZONE_ID)).isEqualTo("+10:00");
+        assertThat(setSessionProperties).containsEntry(TIME_ZONE_ID, "+10:00");
     }
 
     @Test
@@ -190,7 +190,7 @@ public void testSetTimeZoneIntervalDayTimeTypeFunctionCall()
 
         Map<String, String> setSessionProperties = stateMachine.getSetSessionProperties();
         assertThat(setSessionProperties).hasSize(1);
-        assertThat(setSessionProperties.get(TIME_ZONE_ID)).isEqualTo("+08:00");
+        assertThat(setSessionProperties).containsEntry(TIME_ZONE_ID, "+08:00");
     }
 
     @Test
@@ -246,7 +246,7 @@ public void testSetTimeIntervalLiteralZoneHourToMinute()
 
         Map<String, String> setSessionProperties = stateMachine.getSetSessionProperties();
         assertThat(setSessionProperties).hasSize(1);
-        assertThat(setSessionProperties.get(TIME_ZONE_ID)).isEqualTo("-08:00");
+        assertThat(setSessionProperties).containsEntry(TIME_ZONE_ID, "-08:00");
     }
 
     private QueryStateMachine createQueryStateMachine(String query)

core/trino-main/src/test/java/io/trino/execution/scheduler/TestPartitionedPipelinedOutputBufferManager.java

@@ -59,7 +59,7 @@ private static void assertOutputBuffers(PipelinedOutputBuffers outputBuffers)
         Map<OutputBufferId, Integer> buffers = outputBuffers.getBuffers();
         assertThat(buffers.size()).isEqualTo(4);
         for (int partition = 0; partition < 4; partition++) {
-            assertThat(buffers.get(new OutputBufferId(partition))).isEqualTo(Integer.valueOf(partition));
+            assertThat(buffers).containsEntry(new OutputBufferId(partition), Integer.valueOf(partition));
         }
     }
 }

core/trino-main/src/test/java/io/trino/server/security/jwt/TestJwkService.java

@@ -197,8 +197,8 @@ private static void assertTestKeys(JwkService service)
     {
         Map<String, PublicKey> keys = service.getKeys();
         assertThat(keys.size()).isEqualTo(3);
-        assertThat(keys.containsKey("test-rsa")).isTrue();
-        assertThat(keys.containsKey("test-ec")).isTrue();
-        assertThat(keys.containsKey("test-certificate-chain")).isTrue();
+        assertThat(keys).containsKey("test-rsa");
+        assertThat(keys).containsKey("test-ec");
+        assertThat(keys).containsKey("test-certificate-chain");
     }
 }

core/trino-main/src/test/java/io/trino/sql/planner/TestPartialTranslator.java

@@ -103,7 +103,7 @@ private void assertPartialTranslation(Expression expression, List<Expression> su
         Map<NodeRef<Expression>, ConnectorExpression> translation = extractPartialTranslations(expression, TEST_SESSION, TYPE_ANALYZER, TYPE_PROVIDER, PLANNER_CONTEXT);
         assertThat(subexpressions.size()).isEqualTo(translation.size());
         for (Expression subexpression : subexpressions) {
-            assertThat(translation.get(NodeRef.of(subexpression))).isEqualTo(translate(TEST_SESSION, subexpression, TYPE_PROVIDER, PLANNER_CONTEXT, TYPE_ANALYZER).get());
+            assertThat(translation).containsEntry(NodeRef.of(subexpression), translate(TEST_SESSION, subexpression, TYPE_PROVIDER, PLANNER_CONTEXT, TYPE_ANALYZER).get());
         }
     }
 

lib/trino-geospatial-toolkit/src/test/java/io/trino/geospatial/TestKdbTree.java

@@ -96,8 +96,8 @@ private void testSplitVertically(double width, double height)
         Map<Integer, Rectangle> leafNodes = treeCopy.getLeaves();
         assertThat(leafNodes.size()).isEqualTo(2);
         assertThat(leafNodes.keySet()).isEqualTo(ImmutableSet.of(0, 1));
-        assertThat(leafNodes.get(0)).isEqualTo(new Rectangle(0, 0, 4.5, 4));
-        assertThat(leafNodes.get(1)).isEqualTo(new Rectangle(4.5, 0, 9, 4));
+        assertThat(leafNodes).containsEntry(0, new Rectangle(0, 0, 4.5, 4));
+        assertThat(leafNodes).containsEntry(1, new Rectangle(4.5, 0, 9, 4));
 
         assertPartitions(treeCopy, new Rectangle(1, 1, 2, 2), ImmutableSet.of(0));
         assertPartitions(treeCopy, new Rectangle(1, 1, 5, 2), ImmutableSet.of(0, 1));
@@ -125,8 +125,8 @@ private void testSplitHorizontally(double width, double height)
         Map<Integer, Rectangle> leafNodes = tree.getLeaves();
         assertThat(leafNodes.size()).isEqualTo(2);
         assertThat(leafNodes.keySet()).isEqualTo(ImmutableSet.of(0, 1));
-        assertThat(leafNodes.get(0)).isEqualTo(new Rectangle(0, 0, 4, 4.5));
-        assertThat(leafNodes.get(1)).isEqualTo(new Rectangle(0, 4.5, 4, 9));
+        assertThat(leafNodes).containsEntry(0, new Rectangle(0, 0, 4, 4.5));
+        assertThat(leafNodes).containsEntry(1, new Rectangle(0, 4.5, 4, 9));
 
         // points inside and outside partitions
         assertPartitions(tree, new Rectangle(1, 1, 1, 1), ImmutableSet.of(0));
@@ -172,12 +172,12 @@ private void testEvenDistribution(double width, double height)
         Map<Integer, Rectangle> leafNodes = tree.getLeaves();
         assertThat(leafNodes.size()).isEqualTo(6);
         assertThat(leafNodes.keySet()).isEqualTo(ImmutableSet.of(0, 1, 2, 3, 4, 5));
-        assertThat(leafNodes.get(0)).isEqualTo(new Rectangle(0, 0, 2.5, 2.5));
-        assertThat(leafNodes.get(1)).isEqualTo(new Rectangle(0, 2.5, 2.5, 4));
-        assertThat(leafNodes.get(2)).isEqualTo(new Rectangle(2.5, 0, 4.5, 4));
-        assertThat(leafNodes.get(3)).isEqualTo(new Rectangle(4.5, 0, 7.5, 2.5));
-        assertThat(leafNodes.get(4)).isEqualTo(new Rectangle(4.5, 2.5, 7.5, 4));
-        assertThat(leafNodes.get(5)).isEqualTo(new Rectangle(7.5, 0, 9, 4));
+        assertThat(leafNodes).containsEntry(0, new Rectangle(0, 0, 2.5, 2.5));
+        assertThat(leafNodes).containsEntry(1, new Rectangle(0, 2.5, 2.5, 4));
+        assertThat(leafNodes).containsEntry(2, new Rectangle(2.5, 0, 4.5, 4));
+        assertThat(leafNodes).containsEntry(3, new Rectangle(4.5, 0, 7.5, 2.5));
+        assertThat(leafNodes).containsEntry(4, new Rectangle(4.5, 2.5, 7.5, 4));
+        assertThat(leafNodes).containsEntry(5, new Rectangle(7.5, 0, 9, 4));
     }
 
     @Test
@@ -208,15 +208,15 @@ private void testSkewedDistribution(double width, double height)
         Map<Integer, Rectangle> leafNodes = tree.getLeaves();
         assertThat(leafNodes.size()).isEqualTo(9);
         assertThat(leafNodes.keySet()).isEqualTo(ImmutableSet.of(0, 1, 2, 3, 4, 5, 6, 7, 8));
-        assertThat(leafNodes.get(0)).isEqualTo(new Rectangle(0, 0, 1.5, 2.5));
-        assertThat(leafNodes.get(1)).isEqualTo(new Rectangle(1.5, 0, 3.5, 2.5));
-        assertThat(leafNodes.get(2)).isEqualTo(new Rectangle(0, 2.5, 3.5, 4));
-        assertThat(leafNodes.get(3)).isEqualTo(new Rectangle(3.5, 0, 5.1, 1.75));
-        assertThat(leafNodes.get(4)).isEqualTo(new Rectangle(3.5, 1.75, 5.1, 4));
-        assertThat(leafNodes.get(5)).isEqualTo(new Rectangle(5.1, 0, 5.9, 1.75));
-        assertThat(leafNodes.get(6)).isEqualTo(new Rectangle(5.9, 0, 9, 1.75));
-        assertThat(leafNodes.get(7)).isEqualTo(new Rectangle(5.1, 1.75, 7.5, 4));
-        assertThat(leafNodes.get(8)).isEqualTo(new Rectangle(7.5, 1.75, 9, 4));
+        assertThat(leafNodes).containsEntry(0, new Rectangle(0, 0, 1.5, 2.5));
+        assertThat(leafNodes).containsEntry(1, new Rectangle(1.5, 0, 3.5, 2.5));
+        assertThat(leafNodes).containsEntry(2, new Rectangle(0, 2.5, 3.5, 4));
+        assertThat(leafNodes).containsEntry(3, new Rectangle(3.5, 0, 5.1, 1.75));
+        assertThat(leafNodes).containsEntry(4, new Rectangle(3.5, 1.75, 5.1, 4));
+        assertThat(leafNodes).containsEntry(5, new Rectangle(5.1, 0, 5.9, 1.75));
+        assertThat(leafNodes).containsEntry(6, new Rectangle(5.9, 0, 9, 1.75));
+        assertThat(leafNodes).containsEntry(7, new Rectangle(5.1, 1.75, 7.5, 4));
+        assertThat(leafNodes).containsEntry(8, new Rectangle(7.5, 1.75, 9, 4));
     }
 
     @Test
@@ -242,16 +242,16 @@ private void testCantSplitVertically(double width, double height)
         Map<Integer, Rectangle> leafNodes = tree.getLeaves();
         assertThat(leafNodes.size()).isEqualTo(10);
         assertThat(leafNodes.keySet()).isEqualTo(ImmutableSet.of(0, 1, 2, 3, 4, 5, 6, 7, 8, 9));
-        assertThat(leafNodes.get(0)).isEqualTo(new Rectangle(0, 0, 4.5, 0.5));
-        assertThat(leafNodes.get(1)).isEqualTo(new Rectangle(0, 0.5, 4.5, 1.5));
-        assertThat(leafNodes.get(2)).isEqualTo(new Rectangle(0, 1.5, 4.5, 2.5));
-        assertThat(leafNodes.get(3)).isEqualTo(new Rectangle(0, 2.5, 4.5, 3.5));
-        assertThat(leafNodes.get(4)).isEqualTo(new Rectangle(0, 3.5, 4.5, 4 + height));
-        assertThat(leafNodes.get(5)).isEqualTo(new Rectangle(4.5, 0, 9 + width, 0.5));
-        assertThat(leafNodes.get(6)).isEqualTo(new Rectangle(4.5, 0.5, 9 + width, 1.5));
-        assertThat(leafNodes.get(7)).isEqualTo(new Rectangle(4.5, 1.5, 9 + width, 2.5));
-        assertThat(leafNodes.get(8)).isEqualTo(new Rectangle(4.5, 2.5, 9 + width, 3.5));
-        assertThat(leafNodes.get(9)).isEqualTo(new Rectangle(4.5, 3.5, 9 + width, 4 + height));
+        assertThat(leafNodes).containsEntry(0, new Rectangle(0, 0, 4.5, 0.5));
+        assertThat(leafNodes).containsEntry(1, new Rectangle(0, 0.5, 4.5, 1.5));
+        assertThat(leafNodes).containsEntry(2, new Rectangle(0, 1.5, 4.5, 2.5));
+        assertThat(leafNodes).containsEntry(3, new Rectangle(0, 2.5, 4.5, 3.5));
+        assertThat(leafNodes).containsEntry(4, new Rectangle(0, 3.5, 4.5, 4 + height));
+        assertThat(leafNodes).containsEntry(5, new Rectangle(4.5, 0, 9 + width, 0.5));
+        assertThat(leafNodes).containsEntry(6, new Rectangle(4.5, 0.5, 9 + width, 1.5));
+        assertThat(leafNodes).containsEntry(7, new Rectangle(4.5, 1.5, 9 + width, 2.5));
+        assertThat(leafNodes).containsEntry(8, new Rectangle(4.5, 2.5, 9 + width, 3.5));
+        assertThat(leafNodes).containsEntry(9, new Rectangle(4.5, 3.5, 9 + width, 4 + height));
     }
 
     @Test
@@ -277,7 +277,7 @@ private void testCantSplit(double width, double height)
         Map<Integer, Rectangle> leafNodes = tree.getLeaves();
         assertThat(leafNodes.size()).isEqualTo(2);
         assertThat(leafNodes.keySet()).isEqualTo(ImmutableSet.of(0, 1));
-        assertThat(leafNodes.get(0)).isEqualTo(new Rectangle(0, 0, 4.5, 4 + height));
-        assertThat(leafNodes.get(1)).isEqualTo(new Rectangle(4.5, 0, 9 + width, 4 + height));
+        assertThat(leafNodes).containsEntry(0, new Rectangle(0, 0, 4.5, 4 + height));
+        assertThat(leafNodes).containsEntry(1, new Rectangle(4.5, 0, 9 + width, 4 + height));
     }
 }

lib/trino-hdfs/src/test/java/io/trino/hdfs/TestHdfsConfig.java

@@ -104,7 +104,7 @@ public void testNewDirectoryPermissionsMapping()
         HdfsConfig expected = new HdfsConfig()
                 .setNewDirectoryPermissions("skip");
 
-        assertThat(properties.get("hive.fs.new-directory-permissions")).isEqualTo(expected.getNewDirectoryPermissions());
+        assertThat(properties).containsEntry("hive.fs.new-directory-permissions", expected.getNewDirectoryPermissions());
         assertThat(Optional.empty()).isEqualTo(expected.getNewDirectoryFsPermissions());
     }
 }

lib/trino-record-decoder/src/test/java/io/trino/decoder/json/JsonFieldDecoderTester.java

@@ -145,9 +145,7 @@ private FieldValueProvider decode(Optional<String> jsonValue, Type type)
         RowDecoder rowDecoder = DECODER_FACTORY.create(TESTING_SESSION, new RowDecoderSpec(JsonRowDecoder.NAME, emptyMap(), ImmutableSet.of(columnHandle)));
         Map<DecoderColumnHandle, FieldValueProvider> decodedRow = rowDecoder.decodeRow(json.getBytes(UTF_8))
                 .orElseThrow(AssertionError::new);
-        assertThat(decodedRow.containsKey(columnHandle))
-                .describedAs(format("column '%s' not found in decoded row", columnHandle.getName()))
-                .isTrue();
+        assertThat(decodedRow).containsKey(columnHandle);
         return decodedRow.get(columnHandle);
     }
 }

plugin/trino-cassandra/src/test/java/io/trino/plugin/cassandra/TestCassandraConnector.java

@@ -155,14 +155,14 @@ public void tearDown()
     public void testGetDatabaseNames()
     {
         List<String> databases = metadata.listSchemaNames(SESSION);
-        assertThat(databases.contains(database.toLowerCase(ENGLISH))).isTrue();
+        assertThat(databases).contains(database.toLowerCase(ENGLISH));
     }
 
     @Test
     public void testGetTableNames()
     {
         List<SchemaTableName> tables = metadata.listTables(SESSION, Optional.of(database));
-        assertThat(tables.contains(table)).isTrue();
+        assertThat(tables).contains(table);
     }
 
     @Test