// Copyright 2018 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.

library fidljstest;

enum Blorp : int8 {
  ALPHA = 1;
  BETA = 2;
  GAMMA = 0x48;
};

// A struct of basic types, some with defaults and some without to test various
// paths of the generator.
struct BasicStruct {
  bool b;
  int8 i8;
  int16 i16 = 18;
  int32 i32;
  uint8 u8;
  uint16 u16;
  uint32 u32 = 4000000000;
};

const uint64 ARRRR_SIZE = 32;

struct StuffAndThings {
  int32 count;
  string id;
  vector<int32> a_vector;
  BasicStruct basic;
  string later_string;
  array<int32>:ARRRR_SIZE arrrr;
  vector<string>? nullable_vector_of_string0;
  vector<string>? nullable_vector_of_string1;
  vector<Blorp> vector_of_blorp;
};

struct StructWithBool {
  bool some_bool = false;
};

struct StructWithUint {
  uint32 num;
};

struct LargerStructWithArray {
  array<int32>:32 components;
};

union UnionOfStructs {
  StructWithBool swb;
  StructWithUint swu;
  LargerStructWithArray lswa;
};

struct StructOfMultipleUnions {
  UnionOfStructs initial;
  UnionOfStructs? optional;
  UnionOfStructs trailing;
};

const int64 NO_TIMESTAMP = 0x7fffffffffffffff;
const int64 ANOTHER_COPY = NO_TIMESTAMP;
const string SOME_STRING = "a 你好 thing\" containing ' quotes";

struct VariousDefaults {
  Blorp blorp_defaulting_to_beta = BETA;
  int64 int64_defaulting_to_no_timestamp = NO_TIMESTAMP;
  int64 int64_defaulting_to_const = 0x7fffffffffffff11;
  string string_with_default = "stuff";
};

struct VectorsOfPrimitives {
  vector<bool> v_bool;
  vector<uint8> v_uint8;
  vector<uint16> v_uint16;
  vector<uint32> v_uint32;
  vector<uint64> v_uint64;
  vector<int8> v_int8;
  vector<int16> v_int16;
  vector<int32> v_int32;
  vector<int64> v_int64;
  vector<float32> v_float32;
  vector<float64> v_float64;
};

struct VectorOfHandleToVMO {
  vector<handle<vmo>> vmos;
};

// This is a compile-only test for gen.py to ensure that the size of
// AfterPreviousReference is available before the vector<AfterPreviousReference>
// is compiled in this struct.
struct LaterReference {
  vector<AfterPreviousReference>? later;
};

struct AfterPreviousReference {
  int32 an_int;
};

protocol AnotherInterface {
  TimesTwo(int32 a) -> (int32 b);
};

protocol Testola {
  DoSomething();

  PrintInt(int32 num);

  PrintMsg(string msg);

  VariousArgs(Blorp blorp, string:32 msg, vector<uint32> stuff);

  WithResponse(int32 a, int32 b) -> (int32 sum);

  SendAStruct(BasicStruct basic);

  NestedStructsWithResponse(BasicStruct basic) -> (StuffAndThings resp);

  PassHandles(handle<job> job) -> (handle<process> process);

  ReceiveUnions(StructOfMultipleUnions somu);

  SendUnions() -> (StructOfMultipleUnions somu);

  SendVectorsOfString(vector<string> unsized,
                      vector<string?> nullable,
                      vector<string:10> max_strlen);

  VectorOfStruct(vector<StructWithUint> stuff)
    -> (vector<StructWithUint> result);

  PassVectorOfPrimitives(VectorsOfPrimitives input)
    -> (VectorsOfPrimitives output);

  PassVectorOfVMO(VectorOfHandleToVMO input)
    -> (VectorOfHandleToVMO output);

  GetAnother(request<AnotherInterface> another);
};