@pytest.mark.parametrize(
    "type_value",
    [
        "array",
        ["string", "null"],
        None,
    ],
)
def test_allowed_schema_type(
    type_value: Optional[Union[SchemaType, list[SchemaType]]],
) -> None:
    """Test that Schema accepts SchemaType, List[SchemaType] and None for type field."""
    schema = Schema(type=type_value)
    assert schema.type == type_value

package migrator

import (
	"database/sql"
)

// TableType table type implements TableType interface
type TableType struct {
	SchemaValue  string
	NameValue    string
	TypeValue    string
	CommentValue sql.NullString
}

// Schema returns the schema of the table.
func (ct TableType) Schema() string {
	return ct.SchemaValue
}

// Name returns the name of the table.
func (ct TableType) Name() string {

    assertThat(
      mergeAdjacentRanges(
        listOf(
          Mapping(0x0232, 0x0232, TYPE_MAPPED, "a".encodeUtf8()),
          Mapping(0x0233, 0x0233, TYPE_VALID, ByteString.EMPTY),
          Mapping(0x0234, 0x0236, TYPE_VALID, ByteString.EMPTY),
          Mapping(0x0237, 0x0239, TYPE_VALID, ByteString.EMPTY),
          Mapping(0x023a, 0x023a, TYPE_MAPPED, "b".encodeUtf8()),
        ),
      ),
    ).containsExactly(

        Field ptypeField = DcerpcMessage.class.getDeclaredField("ptype");
        ptypeField.setAccessible(true);
        int ptypeValue = (int) ptypeField.get(request);
        assertEquals(0, ptypeValue, "The 'ptype' field should be initialized to 0.");

        Field flagsField = DcerpcMessage.class.getDeclaredField("flags");
        flagsField.setAccessible(true);

        // Then - Use reflection to verify protected field
        Field ptypeField = DcerpcMessage.class.getDeclaredField("ptype");
        ptypeField.setAccessible(true);
        int ptypeValue = (int) ptypeField.get(msrpcSamrConnect2);
        assertEquals(0, ptypeValue, "The 'ptype' field should be initialized to 0");
    }

    @Test
    @DisplayName("Should set flags to DCERPC_FIRST_FRAG | DCERPC_LAST_FRAG")

  when (type) {
    TYPE_IGNORED -> TYPE_IGNORED

    TYPE_MAPPED,
    TYPE_DISALLOWED_STD3_MAPPED,
    -> TYPE_MAPPED

    TYPE_DEVIATION,
    TYPE_DISALLOWED_STD3_VALID,
    TYPE_VALID,
    -> TYPE_VALID

    TYPE_DISALLOWED -> TYPE_DISALLOWED

    else -> error("unexpected type: $type")
  }

internal infix fun Byte.and(mask: Int): Int = toInt() and mask

    when (mapping.type) {
      TYPE_IGNORED -> Unit
      TYPE_MAPPED, TYPE_DISALLOWED_STD3_MAPPED -> {
        sink.write(mapping.mappedTo)
      }

      TYPE_DEVIATION, TYPE_DISALLOWED_STD3_VALID, TYPE_VALID -> {
        sink.writeUtf8CodePoint(codePoint)
      }

      TYPE_DISALLOWED -> {
        sink.writeUtf8CodePoint(codePoint)
        result = false
      }
    }

    return result
  }
}

  data class Constant(
    override val rangeStart: Int,
    val type: Int,
  ) : MappedRange {
    val b1: Int
      get() =
        when (type) {
          TYPE_IGNORED -> 119
          TYPE_VALID -> 120
          TYPE_DISALLOWED -> 121
          else -> error("unexpected type: $type")
        }
  }

  data class Inline1(
    override val rangeStart: Int,
    private val mappedTo: ByteString,