content / web_test / common / mojo_optional_numerics_unittest.mojom [blame]

// Copyright 2023 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

module content.optional_numerics_unittest.mojom;

enum RegularEnum {
  kFoo = 1,
  kBar = 2,
};

// Struct made out of optional numerics.
struct OptionalNumericsStruct {
  bool? optional_bool;
  uint8? optional_uint8;
  int8? optional_int8;
  uint16? optional_uint16;
  int16? optional_int16;
  uint32? optional_uint32;
  int32? optional_int32;
  uint64? optional_uint64;
  int64? optional_int64;
  float? optional_float;
  double? optional_double;
  RegularEnum? optional_enum;
};

// There are two implementations of this interface: a C++ one to test
// JS correctly encodes optional numerics in function params and a JS one to
// test JS correctly decodes optional numerics in function params.
interface Params {
  // The following methods help test that JS correctly handles null optional
  // numerics.
  //
  // Runs the empty callback. CHECKs if `optional_bool` is not null.
  SendNullBool(bool? optional_bool) => ();
  // Runs the empty callback. CHECKs if `optional_uint8` is not null.
  SendNullUint8(uint8? optional_uint8) => ();
  // Runs the empty callback. CHECKs if `optional_int8` is not null.
  SendNullInt8(int8? optional_int8) => ();
  // Runs the empty callback. CHECKs if `optional_uint16` is not null.
  SendNullUint16(uint16? optional_uint16) => ();
  // Runs the empty callback. CHECKs if `optional_int16` is not null.
  SendNullInt16(int16? optional_int16) => ();
  // Runs the empty callback. CHECKs if `optional_uint32` is not null.
  SendNullUint32(uint32? optional_uint32) => ();
  // Runs the empty callback. CHECKs if `optional_int32` is not null.
  SendNullInt32(int32? optional_int32) => ();
  // Runs the empty callback. CHECKs if `optional_uint64` is not null.
  SendNullUint64(uint64? optional_uint64) => ();
  // Runs the empty callback. CHECKs if `optional_int64` is not null.
  SendNullInt64(int64? optional_int64) => ();
  // Runs the empty callback. CHECKs if `optional_float` is not null.
  SendNullFloat(float? optional_float) => ();
  // Runs the empty callback. CHECKs if `optional_double` is not null.
  SendNullDouble(double? optional_double) => ();
  // Runs the empty callback. CHECKs if `optional_enum` is not null.
  SendNullEnum(RegularEnum? optional_enum) => ();

  // Runs the empty callback. CHECKs if `optional_bools` is not null.
  SendNullBools(array<bool?> optional_bools) => ();
  // Runs the empty callback. CHECKs if `optional_int16s` is not null.
  SendNullInt16s(array<int16?> optional_int16s) => ();
  // Runs the empty callback. CHECKs if `optional_uint32s` is not null.
  SendNullUint32s(array<uint32?> optional_uint32s) => ();
  // Runs the empty callback. CHECKs if `optional_doubles` is not null.
  SendNullDoubles(array<double?> optional_doubles) => ();
  // Runs the empty callback. CHECKs if `optional_enums` is not null.
  SendNullEnums(array<RegularEnum?> optional_enums) => ();

  // Runs the empty callback. CHECKs if `optional_bools` is not null.
  SendNullBoolMap(map<int32, bool?> values) => ();
  // Runs the empty callback. CHECKs if `optional_bools` is not null.
  SendNullDoubleMap(map<int32, double?> values) => ();
  // Runs the empty callback. CHECKs if `optional_bools` is not null.
  SendNullEnumMap(map<int32, RegularEnum?> values) => ();

  // The following methods help test that JS correctly handles optional
  // numerics with a value.
  //
  // Runs callback with `optional_bool`.
  SendOptionalBool(bool? optional_bool) => (bool value);
  // Runs callback with `optional_uint8`.
  SendOptionalUint8(uint8? optional_uint8) => (uint8 value);
  // Runs callback with `optional_int8`.
  SendOptionalInt8(int8? optional_int8) => (int8 value);
  // Runs callback with `optional_uint16`.
  SendOptionalUint16(uint16? optional_uint16) => (uint16 value);
  // Runs callback with `optional_int16`.
  SendOptionalInt16(int16? optional_int16) => (int16 value);
  // Runs callback with `optional_uint32`.
  SendOptionalUint32(uint32? optional_uint32) => (uint32 value);
  // Runs callback with `optional_int32`.
  SendOptionalInt32(int32? optional_int32) => (int32 value);
  // Runs callback with `optional_uint64`.
  SendOptionalUint64(uint64? optional_uint64) => (uint64 value);
  // Runs callback with `optional_int64`.
  SendOptionalInt64(int64? optional_int64) => (int64 value);
  // Runs callback with `optional_float`.
  SendOptionalFloat(float? optional_float) => (float value);
  // Runs callback with `optional_double`.
  SendOptionalDouble(double? optional_double) => (double value);
  // Runs callback with `optional_enum`.
  SendOptionalEnum(RegularEnum? optional_enum) => (RegularEnum value);

  // Runs callback with `optional_enum`.
  SendOptionalBools(array<bool?> optional_enums) => (array<bool> values);
  // Runs callback with `optional_int16`.
  SendOptionalInt16s(array<int16?> optional_int16s) => (array<int16> values);
  // Runs callback with `optional_uint32`.
  SendOptionalUint32s(array<uint32?> optional_uint32s)
        => (array<uint32> values);
  // Runs callback with `optional_double`.
  SendOptionalDoubles(array<double?> optional_doubles)
        => (array<double> values);
  // Runs callback with `optional_enum`.
  SendOptionalEnums(array<RegularEnum?> optional_enums)
        => (array<RegularEnum> values);

  // Runs callback by unwrapping all null values.
  SendOptionalBoolMap(map<int32, bool?> values)
        => (map<int32, bool> values);
  // Runs callback by unwrapping all null values.
  SendOptionalDoubleMap(map<int32, double?> values)
        => (map<int32, double> values);
  // Runs callback by unwrapping all null values.
  SendOptionalEnumMap(map<int32, RegularEnum?> values)
        => (map<int32, RegularEnum> values);

  // Runs a callback with null. Helps test that JS can correctly handle null
  // structs with optional numerics.
  SendNullStructWithOptionalNumerics(OptionalNumericsStruct? s) => ();

  // Helps test that JS can correctly handle a struct with null optional
  // numerics.
  // Runs the empty callback. CHECKs if the values in the struct are not null.
  SendStructWithNullOptionalNumerics(OptionalNumericsStruct s) => ();

  // Runs callback the values in the struct. Helps test that JS can correctly
  // handle a struct with optional numerics.
  SendStructWithOptionalNumerics(OptionalNumericsStruct s) => (
    bool bool_value,
    uint8 uint8_value,
    int8 int8_value,
    uint16 uint16_value,
    int16 int16_value,
    uint32 uint32_value,
    int32 int32_value,
    uint64 uint64_value,
    int64 int64_value,
    float float_value,
    double double_value,
    RegularEnum enum_value);
};

// There are two implementations of this interface: a C++ one to test
// JS correctly decodes optional numerics in response params and a JS one to
// test JS correctly encodes optional numerics in response params.
interface ResponseParams {
  // The following methods help test that JS can correctly handle null optional
  // numerics in response params.
  //
  // Returns a null optional bool.
  GetNullBool() => (bool? optional_value);
  // Returns a null optional uint8.
  GetNullUint8() => (uint8? optional_value);
  // Returns a null optional int8.
  GetNullInt8() => (int8? optional_value);
  // // Returns a null optional uint16.
  GetNullUint16() => (uint16? optional_value);
  // // Returns a null optional int16.
  GetNullInt16() => (int16? optional_value);
  // // Returns a null optional uint32.
  GetNullUint32() => (uint32? optional_value);
  // // Returns a null optional int32.
  GetNullInt32() => (int32? optional_value);
  // Returns a null optional uint64.
  GetNullUint64() => (uint64? optional_value);
  // Returns a null optional int64.
  GetNullInt64() => (int64? optional_value);
  // Returns a null optional float.
  GetNullFloat() => (float? optional_value);
  // Returns a null optional double.
  GetNullDouble() => (double? optional_value);
  // Returns a null optional enum.
  GetNullEnum() => (RegularEnum? optional_value);

  // Returns a list of optional bools.
  GetNullBools() => (array<bool?> optional_values);
  // Returns a list of optional int16s.
  GetNullInt16s() => (array<int16?> optional_values);
  // Returns a list of optional uint32s.
  GetNullUint32s() => (array<uint32?> optional_values);
  // Returns a list of optional doubles.
  GetNullDoubles() => (array<double?> optional_values);
  // Returns a list of optional enums.
  GetNullEnums() => (array<RegularEnum?> optional_values);

  // Returns a simple map with a single {0, null} entry.
  GetNullBoolMap() => (map<int16, bool?> optional_values);
  // Returns a simple map with a single {0, null} entry.
  GetNullInt32Map() => (map<int16, int32?> optional_values);
  // Returns a simple map with a single {0, null} entry.
  GetNullEnumMap() => (map<int16, RegularEnum?> optional_values);

  // The following methods help test that JS can correctly handle optional
  // numerics in response params.
  //
  // Returns |value| in an optional bool.
  GetOptionalBool(bool value) => (bool? optional_value);
  // Returns |value| in an optional unit8.
  GetOptionalUint8(uint8 value) => (uint8? optional_value);
  // Returns |value| in an optional int8.
  GetOptionalInt8(int8 value) => (int8? optional_value);
  // Returns |value| in an optional uint16.
  GetOptionalUint16(uint16 value) => (uint16? optional_value);
  // Returns |value| in an optional int16.
  GetOptionalInt16(int16 value) => (int16? optional_value);
  // Returns |value| in an optional uint32.
  GetOptionalUint32(uint32 value) => (uint32? optional_value);
  // Returns |value| in an optional int32.
  GetOptionalInt32(int32 value) => (int32? optional_value);
  // Returns |value| in an optional uint64.
  GetOptionalUint64(uint64 value) => (uint64? optional_value);
  // Returns |value| in an optional int64.
  GetOptionalInt64(int64 value) => (int64? optional_value);
  // Returns |value| in an optional float.
  GetOptionalFloat(float value) => (float? optional_value);
  // Returns |value| in an optional double.
  GetOptionalDouble(double value) => (double? optional_value);
  // Returns |value| in an optional enum.
  GetOptionalEnum(RegularEnum value) => (RegularEnum? optional_value);

  // Returns |value| sandwiched between two null values. E.g.:
  // [null, |value|, null].
  GetOptionalBools(bool value) => (array<bool?> optional_values);
  // Returns |value| sandwiched between two null values. E.g.:
  // [null, |value|, null].
  GetOptionalInt16s(int16 value) => (array<int16?> optional_values);
  // Returns |value| sandwiched between two null values. E.g.:
  // [null, |value|, null].
  GetOptionalUint32s(uint32 value) => (array<uint32?> optional_values);
  // Returns |value| sandwiched between two null values. E.g.:
  // [null, |value|, null].
  GetOptionalDoubles(double value) => (array<double?> optional_values);
  // Returns |value| sandwiched between two null values. E.g.:
  // [null, |value|, null].
  GetOptionalEnums(RegularEnum value) => (array<RegularEnum?> optional_values);

  // Returns {|key|, |value|} sandwiched between two null values. E.g.:
  // {
  //   [key - 1]: null,
  //   [key]: value,
  //   [key +1]: value,
  // }
  GetOptionalBoolMap(int16 key, bool value)
        => (map<int16, bool?> optional_values);
  // Same as above.
  GetOptionalFloatMap(int16 key, float value)
        => (map<int16, float?> optional_values);
  // Same as above.
  GetOptionalEnumMap(int16 key, RegularEnum value)
        => (map<int16, RegularEnum?> optional_values);

  // Runs a callback with null. Helps test that JS can correctly handle null
  // structs with optional numerics.
  GetNullStructWithOptionalNumerics() => (OptionalNumericsStruct? s);

  // Returns a struct with null optional numerics. Helps test that JS can
  // correctly handle structs with null optional numerics.
  GetStructWithNullOptionalNumerics() => (OptionalNumericsStruct s);

  // Returns a struct with values as optional numerics. Helps test that JS can
  // correctly handle struct with optional numerics.
  GetStructWithOptionalNumerics(
    bool bool_value,
    uint8 uint8_value,
    int8 int8_value,
    uint16 uint16_value,
    int16 int16_value,
    uint32 uint32_value,
    int32 int32_value,
    uint64 uint64_value,
    int64 int64_value,
    float float_value,
    double double_value,
    RegularEnum enum_value) => (OptionalNumericsStruct s);
};

struct VersionedStructV0 {
};

struct VersionedStructV2 {
  [MinVersion=2] bool? bool_value;
  [MinVersion=2] uint8? uint8_value;
  [MinVersion=2] int8? int8_value;
  [MinVersion=2] uint16? uint16_value;
  [MinVersion=2] int16? int16_value;
  [MinVersion=2] uint32? uint32_value;
  [MinVersion=2] int32? int32_value;
  [MinVersion=2] uint64? uint64_value;
  [MinVersion=2] int64? int64_value;
  [MinVersion=2] float? float_value;
  [MinVersion=2] double? double_value;
  [MinVersion=2] RegularEnum? enum_value;
};

// Implemented in JS to test that optional numerics in versioned interfaces
// work.
interface InterfaceV0 {
  // V2 of this method has optional numeric params and response params.
  MethodWithVersionedParams@1() => ();

  // V2 of this method uses VersionedStructV2.
  MethodWithVersionedStruct@2(VersionedStructV0 s) => (VersionedStructV0 s);
};

// Implemented in JS to test that optional numerics in versioned interfaces
// work.
interface InterfaceV2 {
  // Returns the optional numerics it was sent but with some transformations
  // i.e. !bool_value, integers get multiplied by 2, float and double get
  // multiplied by 3.
  MethodWithVersionedParams@1(
    [MinVersion=2] bool? bool_value,
    [MinVersion=2] uint8? uint8_value,
    [MinVersion=2] int8? int8_value,
    [MinVersion=2] uint16? uint16_value,
    [MinVersion=2] int16? int16_value,
    [MinVersion=2] uint32? uint32_value,
    [MinVersion=2] int32? int32_value,
    [MinVersion=2] uint64? uint64_value,
    [MinVersion=2] int64? int64_value,
    [MinVersion=2] float? float_value,
    [MinVersion=2] double? double_value,
    [MinVersion=2] RegularEnum? enum_value
  ) => (
    [MinVersion=2] bool? bool_value,
    [MinVersion=2] uint8? uint8_value,
    [MinVersion=2] int8? int8_value,
    [MinVersion=2] uint16? uint16_value,
    [MinVersion=2] int16? int16_value,
    [MinVersion=2] uint32? uint32_value,
    [MinVersion=2] int32? int32_value,
    [MinVersion=2] uint64? uint64_value,
    [MinVersion=2] int64? int64_value,
    [MinVersion=2] float? float_value,
    [MinVersion=2] double? double_value,
    [MinVersion=2] RegularEnum? enum_value
  );

  // Returns the optional numerics in `s` it was sent but with some
  // transformations i.e. !bool_value, integers get multiplied by 2, float and
  // double get multiplied by 3.
  MethodWithVersionedStruct@2(VersionedStructV2 s) => (VersionedStructV2 s);
};