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

[DartPackage="_mojo_for_test_only",
 JavaPackage="org.chromium.mojo.bindings.test.mojom.mojo"]
module mojo.test;

struct StructA {
  uint64 i;
};

struct StructB {
  StructA struct_a;
};

struct StructC {
  array<uint8> data;
};

struct StructD {
  array<handle<message_pipe>> message_pipes;
};

struct StructE {
  StructD struct_d;
  handle<data_pipe_consumer> data_pipe_consumer;
};

struct StructF {
  array<uint8, 3> fixed_size_array;
};

struct StructG {
  int32 i;
  [MinVersion=1] StructA? struct_a;
  [MinVersion=3] string? str;
  [MinVersion=3] bool b;
};

struct StructH {
  bool a;
  uint8 b;
  UnionA? c;
  array<UnionA>? d;
  map<uint8, UnionA>? e;
};

union UnionA {
  uint16 a;
  uint32 b;
  StructA? c;
  array<uint8>? d;
  map<string, uint8>? e;
  UnionB? f;
  StructA g;
  array<uint8> h;
  map<string, uint8> i;
  UnionB j;
};

union UnionB {
  uint16 a;
  uint32 b;
  uint64 c;
  uint32 d;
};

interface InterfaceA {};

// This interface is used for testing bounds-checking in the mojom
// binding code. If you add a method please update the files
// ./data/validation/boundscheck_*. If you add a response please update
// ./data/validation/resp_boundscheck_*.
[ServiceName="this.is.the.service.name.for.BoundsCheckTestInterface"]
interface BoundsCheckTestInterface {
  Method0(uint8 param0) => (uint8 param0);
  Method1(uint8 param0);
};

interface ConformanceTestInterface {
  Method0(float param0);
  Method1(StructA param0);
  Method2(StructB param0, StructA param1);
  Method3(array<bool> param0);
  Method4(StructC param0, array<uint8> param1);
  Method5(StructE param0, handle<data_pipe_producer> param1);
  Method6(array<array<uint8>> param0);
  Method7(StructF param0, array<array<uint8, 3>?, 2> param1);
  Method8(array<array<string>?> param0);
  Method9(array<array<handle?>>? param0);
  Method10(map<string, uint8> param0);
  Method11(StructG param0);
  Method12(float param0) => (float param0);
  Method13(InterfaceA? param0, uint32 param1, InterfaceA? param2);
  Method14(UnionA param0);
  Method15(StructH param0);
};

struct BasicStruct {
  int32 a;
};

interface IntegrationTestInterface {
  Method0(BasicStruct param0) => (array<uint8> param0);
};

// An enum generates a enum-value validation function, so we want to test it.
// E.g., valid enum values for this enum should be:  -3, 0, 1, 10
enum BasicEnum {
  A,
  B,
  C = A,
  D = -3,
  E = 0xA,
};

// The enum validation function should be generated within the scope of this
// struct.
struct StructWithEnum {
  enum EnumWithin {
    A,
    B,
    C,
    D,
  };
};