// Arrange: pick a value and a mocked consumer
        RequestParam rp = RequestParam.NO_RETRY;

        // Act: pass to the collaborator
        consumer.accept(rp);

        // Assert: interaction happened exactly once with correct argument; no other calls
        verify(consumer, times(1)).accept(RequestParam.NO_RETRY);
        verifyNoMoreInteractions(consumer);
    }

import java.nio.file.Path;
import java.util.Set;
import java.util.TreeSet;
import java.util.stream.Collectors;
import java.util.stream.Stream;
import javax.inject.Inject;

/**
 * Once a minor release has happened, we no longer need to keep the changelog files that went into
 * that release in the development branch for that major series or the branch for the next major
 * series
 * <p>

    /*
     * We need to wait for the runner to exit. It used to be that the runner would get stuck in the
     * busy loop when interrupt threw.
     *
     * While we're at it, we confirm that the interrupt happened as expected.
     */
    ExecutionException fromRunInterruptibly =
        assertThrows(ExecutionException.class, () -> taskResult.get(10, SECONDS));

    /*
     * We need to wait for the runner to exit. It used to be that the runner would get stuck in the
     * busy loop when interrupt threw.
     *
     * While we're at it, we confirm that the interrupt happened as expected.
     */
    ExecutionException fromRunInterruptibly =
        assertThrows(ExecutionException.class, () -> taskResult.get(10, SECONDS));

            lenient().doNothing().when(mockBuffer).setIndex(anyInt());

            message.encode(mockBuffer);

            // Verify key operations happened
            verify(mockBuffer).enc_ndr_small(5); // RPC version
            verify(mockBuffer).enc_ndr_long(0x00000010); // Little-endian / ASCII / IEEE
            verify(mockBuffer).enc_ndr_long(message.call_id);

        assertIterableEquals(Arrays.asList(0x00000000, 0xc0000022, 0xc0000033), ntCaptor.getAllValues());

        // And ensure no further interactions happened
        verifyNoMoreInteractions(consumer);
    }

    // drop the contract on the method that enforces this queue like behavior since depending on it
    // is likely to be a bug anyway.

    // N.B. All writes to the list and the next pointers must have happened before the above
    // synchronized block, so we can iterate the list without the lock held here.
    RunnableExecutorPair reversedList = null;
    while (list != null) {
      RunnableExecutorPair tmp = list;

	}

	var count3 int64
	if err := DB.Model(&User{}).Where("name in ?", []string{user2.Name, user2.Name, user3.Name}).Group("id").Count(&count3).Error; err != nil {
		t.Errorf("Error happened when count with group, but got %v", err)
	}

	if count3 != 2 {
		t.Errorf("Should get correct count for count with group, but got %v", count3)
	}

	dryDB := DB.Session(&gorm.Session{DryRun: true})

	}

	if err := DB.Create(&data).Error; err != nil {
		t.Fatalf("No error should happened when create scanner valuer struct, but got %v", err)
	}

	var result ScannerValuerStruct

	if err := DB.Find(&result, "id = ?", data.ID).Error; err != nil {
		t.Fatalf("no error should happen when query scanner, valuer struct, but got %v", err)
	}

	if result.ExampleStructPtr.Val != "value2" {

      if (e.getCause() instanceof IllegalArgumentException) {
        /*
         * IllegalArgumentException is the one unchecked exception that we know is likely to happen
         * (thanks to the checkArgument calls in getAnnotatedMethodsNotCached). If it happens, we'd
         * prefer to propagate an IllegalArgumentException to the caller. However, we don't want to