// Protocol Buffers - Google's data interchange format
// Copyright 2008 Google Inc.  All rights reserved.
//
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file or at
// https://developers.google.com/open-source/licenses/bsd

syntax = "proto2";

import "google/protobuf/unittest_import.proto";

option cc_enable_arenas = true;

// We don't put this in a package within proto2 because we need to make sure
// that the generated code doesn't depend on being in the proto2 namespace.
// In map_test_util.h we do "using namespace unittest = protobuf_unittest".
package protobuf_unittest;

enum Proto2MapEnum {
  PROTO2_MAP_ENUM_FOO = 0;
  PROTO2_MAP_ENUM_BAR = 1;
  PROTO2_MAP_ENUM_BAZ = 2;
}

enum Proto2MapEnumPlusExtra {
  E_PROTO2_MAP_ENUM_FOO = 0;
  E_PROTO2_MAP_ENUM_BAR = 1;
  E_PROTO2_MAP_ENUM_BAZ = 2;
  E_PROTO2_MAP_ENUM_EXTRA = 3;
}

message TestEnumMap {
  map<int32, Proto2MapEnum> known_map_field = 101;
  map<int32, Proto2MapEnum> unknown_map_field = 102;

  // Other maps with all key types to test the unknown entry serialization
  map<int64, Proto2MapEnum> unknown_map_field_int64 = 200;
  map<uint64, Proto2MapEnum> unknown_map_field_uint64 = 201;
  map<int32, Proto2MapEnum> unknown_map_field_int32 = 202;
  map<uint32, Proto2MapEnum> unknown_map_field_uint32 = 203;
  map<fixed32, Proto2MapEnum> unknown_map_field_fixed32 = 204;
  map<fixed64, Proto2MapEnum> unknown_map_field_fixed64 = 205;
  map<bool, Proto2MapEnum> unknown_map_field_bool = 206;
  map<string, Proto2MapEnum> unknown_map_field_string = 207;
  map<sint32, Proto2MapEnum> unknown_map_field_sint32 = 208;
  map<sint64, Proto2MapEnum> unknown_map_field_sint64 = 209;
  map<sfixed32, Proto2MapEnum> unknown_map_field_sfixed32 = 210;
  map<sfixed64, Proto2MapEnum> unknown_map_field_sfixed64 = 211;
}

message TestEnumMapPlusExtra {
  map<int32, Proto2MapEnumPlusExtra> known_map_field = 101;
  map<int32, Proto2MapEnumPlusExtra> unknown_map_field = 102;

  // Other maps with all key types to test the unknown entry serialization
  map<int64, Proto2MapEnumPlusExtra> unknown_map_field_int64 = 200;
  map<uint64, Proto2MapEnumPlusExtra> unknown_map_field_uint64 = 201;
  map<int32, Proto2MapEnumPlusExtra> unknown_map_field_int32 = 202;
  map<uint32, Proto2MapEnumPlusExtra> unknown_map_field_uint32 = 203;
  map<fixed32, Proto2MapEnumPlusExtra> unknown_map_field_fixed32 = 204;
  map<fixed64, Proto2MapEnumPlusExtra> unknown_map_field_fixed64 = 205;
  map<bool, Proto2MapEnumPlusExtra> unknown_map_field_bool = 206;
  map<string, Proto2MapEnumPlusExtra> unknown_map_field_string = 207;
  map<sint32, Proto2MapEnumPlusExtra> unknown_map_field_sint32 = 208;
  map<sint64, Proto2MapEnumPlusExtra> unknown_map_field_sint64 = 209;
  map<sfixed32, Proto2MapEnumPlusExtra> unknown_map_field_sfixed32 = 210;
  map<sfixed64, Proto2MapEnumPlusExtra> unknown_map_field_sfixed64 = 211;
}

message TestImportEnumMap {
  map<int32, protobuf_unittest_import.ImportEnumForMap> import_enum_amp = 1;
}

message TestIntIntMap {
  map<int32, int32> m = 1;
}

// Test all key types: string, plus the non-floating-point scalars.
message TestMaps {
  map<int32, TestIntIntMap> m_int32 = 1;
  map<int64, TestIntIntMap> m_int64 = 2;
  map<uint32, TestIntIntMap> m_uint32 = 3;
  map<uint64, TestIntIntMap> m_uint64 = 4;
  map<sint32, TestIntIntMap> m_sint32 = 5;
  map<sint64, TestIntIntMap> m_sint64 = 6;
  map<fixed32, TestIntIntMap> m_fixed32 = 7;
  map<fixed64, TestIntIntMap> m_fixed64 = 8;
  map<sfixed32, TestIntIntMap> m_sfixed32 = 9;
  map<sfixed64, TestIntIntMap> m_sfixed64 = 10;
  map<bool, TestIntIntMap> m_bool = 11;
  map<string, TestIntIntMap> m_string = 12;
}

// Test maps in submessages.
message TestSubmessageMaps {
  optional TestMaps m = 1;
}

message TestProto2BytesMap {
  map<int32, bytes> map_bytes = 1;
  map<int32, string> map_string = 2;
}
