"SELECT * FROM `users` FOR SHARE OF `users`", nil,
		},
		{
			[]clause.Interface{clause.Select{}, clause.From{}, clause.Locking{Strength: clause.LockingStrengthUpdate, Options: clause.LockingOptionsNoWait}},
			"SELECT * FROM `users` FOR UPDATE NOWAIT", nil,
		},
		{

        }
    }

    @Test
    public void test_getDeclaringClass() {
        // Test getDeclaringClass returns correct class
        assertEquals(SsoResponseType.class, SsoResponseType.METADATA.getDeclaringClass());
        assertEquals(SsoResponseType.class, SsoResponseType.LOGOUT.getDeclaringClass());
    }

    @Test
    public void test_enumConstantReference() {

	switch len(b.items) {
	case 0:
		return nil
	case 1:
		_, err := b.store.Put(b.items[0])
		return err
	default:
	}
	if _, err := b.store.PutMultiple(b.items); err != nil {
		return err
	}
	b.items = make([]I, 0, b.limit)
	return nil
}

// Close commits the pending items and quits the goroutines
func (b *Batch[I]) Close() error {
	defer func() {
		close(b.quitCh)
	}()

	b.Lock()

        return switch (level) {
            case DEBUG -> Logger.LEVEL_DEBUG;
            case INFO -> Logger.LEVEL_INFO;
            case ERROR -> Logger.LEVEL_ERROR;
        };
    }

    @Nullable
    public static Path findRoot(Path topDirectory) {
        requireNonNull(topDirectory, "topDirectory");
        Path rootDirectory =
                ServiceLoader.load(RootLocator.class).iterator().next().findRoot(topDirectory);

			[]interface{}{"admin"},
		},
		{
			[]clause.Interface{clause.Select{}, clause.From{}, clause.GroupBy{
				Columns: []clause.Column{{Name: "role"}},
				Having:  []clause.Expression{clause.Eq{"role", "admin"}},
			}, clause.GroupBy{
				Columns: []clause.Column{{Name: "gender"}},
				Having:  []clause.Expression{clause.Neq{"gender", "U"}},
			}},

            println(key)
            println(value.content)
          }
        }
      }

      @JsonClass(generateAdapter = true)
      data class Gist(var files: Map<String, GistFile>?)

      @JsonClass(generateAdapter = true)
      data class GistFile(var content: String?)
    ```
=== ":material-language-java: Java"
    ```java
      private final OkHttpClient client = new OkHttpClient();

import (
	"context"
	"database/sql"

	"gorm.io/gorm/clause"
	"gorm.io/gorm/schema"
)

// Dialector GORM database dialector
type Dialector interface {
	Name() string
	Initialize(*DB) error
	Migrator(db *DB) Migrator
	DataTypeOf(*schema.Field) string
	DefaultValueOf(*schema.Field) clause.Expression
	BindVarTo(writer clause.Writer, stmt *Statement, v interface{})
	QuoteTo(clause.Writer, string)

        FileInformation inf;
        switch (this.informationLevel) {
        case FileInformation.FILE_BASIC_INFO:
            inf = new FileBasicInfo();
            break;
        case FileInformation.FILE_STANDARD_INFO:
            inf = new FileStandardInfo();
            break;
        case FileInformation.FILE_INTERNAL_INFO:
            inf = new FileInternalInfo();
            break;

        assertNotNull(memoryLog2);
        assertTrue(memoryLog1.contains("Mem:"));
        assertTrue(memoryLog2.contains("Mem:"));
    }

    // Custom test class for fallback object testing
    private static class CustomTestObject {
        @SuppressWarnings("unused")
        private final String field = "test";
    }

    private long getObjectSize(Object value) {

    switch (unit) {
      case NANOSECONDS:
        return "ns";
      case MICROSECONDS:
        return "\u03bcs"; // μs
      case MILLISECONDS:
        return "ms";
      case SECONDS:
        return "s";
      case MINUTES:
        return "min";
      case HOURS:
        return "h";
      case DAYS:
        return "d";
    }
    throw new AssertionError();