Current section
Files
Jump to
Current section
Files
lib/cucumber_messages/messages.ex
# credo:disable-for-this-file
[
defmodule(CucumberMessages.Attachment.ContentEncoding) do
@moduledoc false
(
(
@spec default() :: :IDENTITY
def(default()) do
:IDENTITY
end
)
@spec encode(atom) :: integer | atom
[
def(encode(:IDENTITY)) do
0
end,
def(encode(:BASE64)) do
1
end
]
def(encode(x)) do
x
end
@spec decode(integer) :: atom | integer
[
def(decode(0)) do
:IDENTITY
end,
def(decode(1)) do
:BASE64
end
]
def(decode(x)) do
x
end
@spec constants() :: [{integer, atom}]
def(constants()) do
[{0, :IDENTITY}, {1, :BASE64}]
end
)
[]
end,
defmodule(CucumberMessages.StepDefinition.StepDefinitionPattern.StepDefinitionPatternType) do
@moduledoc false
(
(
@spec default() :: :CUCUMBER_EXPRESSION
def(default()) do
:CUCUMBER_EXPRESSION
end
)
@spec encode(atom) :: integer | atom
[
def(encode(:CUCUMBER_EXPRESSION)) do
0
end,
def(encode(:REGULAR_EXPRESSION)) do
1
end
]
def(encode(x)) do
x
end
@spec decode(integer) :: atom | integer
[
def(decode(0)) do
:CUCUMBER_EXPRESSION
end,
def(decode(1)) do
:REGULAR_EXPRESSION
end
]
def(decode(x)) do
x
end
@spec constants() :: [{integer, atom}]
def(constants()) do
[{0, :CUCUMBER_EXPRESSION}, {1, :REGULAR_EXPRESSION}]
end
)
[]
end,
defmodule(CucumberMessages.TestStepFinished.TestStepResult.Status) do
@moduledoc false
(
(
@spec default() :: :UNKNOWN
def(default()) do
:UNKNOWN
end
)
@spec encode(atom) :: integer | atom
[
def(encode(:UNKNOWN)) do
0
end,
def(encode(:PASSED)) do
1
end,
def(encode(:SKIPPED)) do
2
end,
def(encode(:PENDING)) do
3
end,
def(encode(:UNDEFINED)) do
4
end,
def(encode(:AMBIGUOUS)) do
5
end,
def(encode(:FAILED)) do
6
end
]
def(encode(x)) do
x
end
@spec decode(integer) :: atom | integer
[
def(decode(0)) do
:UNKNOWN
end,
def(decode(1)) do
:PASSED
end,
def(decode(2)) do
:SKIPPED
end,
def(decode(3)) do
:PENDING
end,
def(decode(4)) do
:UNDEFINED
end,
def(decode(5)) do
:AMBIGUOUS
end,
def(decode(6)) do
:FAILED
end
]
def(decode(x)) do
x
end
@spec constants() :: [{integer, atom}]
def(constants()) do
[
{0, :UNKNOWN},
{1, :PASSED},
{2, :SKIPPED},
{3, :PENDING},
{4, :UNDEFINED},
{5, :AMBIGUOUS},
{6, :FAILED}
]
end
)
[]
end,
defmodule(CucumberMessages.Pickle.PickleTag) do
@moduledoc false
(
defstruct(name: "", ast_node_id: "", __uf__: [])
(
@spec encode(struct) :: {:ok, iodata} | {:error, any}
def(encode(msg)) do
try do
{:ok, encode!(msg)}
rescue
e ->
{:error, e}
end
end
@spec encode!(struct) :: iodata | no_return
def(encode!(msg)) do
[] |> encode_name(msg) |> encode_ast_node_id(msg) |> encode_unknown_fields(msg)
end
[]
[
defp(encode_name(acc, msg)) do
field_value = msg.name()
if(field_value == "") do
acc
else
[acc, "\n", Protox.Encode.encode_string(field_value)]
end
end,
defp(encode_ast_node_id(acc, msg)) do
field_value = msg.ast_node_id()
if(field_value == "") do
acc
else
[acc, <<18>>, Protox.Encode.encode_string(field_value)]
end
end
]
defp(encode_unknown_fields(acc, msg)) do
Enum.reduce(msg.__struct__.unknown_fields(msg), acc, fn {tag, wire_type, bytes}, acc ->
case(wire_type) do
0 ->
[acc, Protox.Encode.make_key_bytes(tag, :int32), bytes]
1 ->
[acc, Protox.Encode.make_key_bytes(tag, :double), bytes]
2 ->
len_bytes = bytes |> byte_size() |> Protox.Varint.encode()
[acc, Protox.Encode.make_key_bytes(tag, :packed), len_bytes, bytes]
5 ->
[acc, Protox.Encode.make_key_bytes(tag, :float), bytes]
end
end)
end
)
(
@spec decode(binary) :: {:ok, struct} | {:error, any}
def(decode(bytes)) do
try do
{:ok, decode!(bytes)}
rescue
Protox.IllegalTagError ->
{:error, :illegal_tag}
e in Protox.RequiredFieldsError ->
{:error, {:missing_fields, e.missing_fields}}
e in Protox.DecodingError ->
{:error, {e.reason, e.binary}}
e ->
{:error, e}
end
end
(
@spec decode!(binary) :: struct | no_return
def(decode!(bytes)) do
parse_key_value(bytes, struct(CucumberMessages.Pickle.PickleTag))
end
)
(
@spec parse_key_value(binary, struct) :: struct
defp(parse_key_value(<<>>, msg)) do
msg
end
defp(parse_key_value(bytes, msg)) do
{field, rest} =
case(Protox.Decode.parse_key(bytes)) do
{0, _, _} ->
raise(%Protox.IllegalTagError{})
{1, _, bytes} ->
{len, bytes} = Protox.Varint.decode(bytes)
<<delimited::binary-size(len), rest::binary>> = bytes
value = delimited
field = {:name, value}
{field, rest}
{2, _, bytes} ->
{len, bytes} = Protox.Varint.decode(bytes)
<<delimited::binary-size(len), rest::binary>> = bytes
value = delimited
field = {:ast_node_id, value}
{field, rest}
{tag, wire_type, rest} ->
{value, new_rest} = Protox.Decode.parse_unknown(tag, wire_type, rest)
field =
{msg.__struct__.unknown_fields_name,
[value | msg.__struct__.unknown_fields(msg)]}
{field, new_rest}
end
msg_updated = struct(msg, [field])
parse_key_value(rest, msg_updated)
end
)
[]
)
@spec defs() :: %{
required(non_neg_integer) => {atom, Protox.Types.kind(), Protox.Types.type()}
}
def(defs()) do
%{1 => {:name, {:default, ""}, :string}, 2 => {:ast_node_id, {:default, ""}, :string}}
end
@spec defs_by_name() :: %{
required(atom) => {non_neg_integer, Protox.Types.kind(), Protox.Types.type()}
}
def(defs_by_name()) do
%{ast_node_id: {2, {:default, ""}, :string}, name: {1, {:default, ""}, :string}}
end
@spec required_fields() :: []
def(required_fields()) do
[]
end
@spec unknown_fields(struct) :: [{non_neg_integer, Protox.Types.tag(), binary}]
def(unknown_fields(msg)) do
msg.__uf__()
end
@spec unknown_fields_name() :: :__uf__
def(unknown_fields_name()) do
:__uf__
end
@spec clear_unknown_fields(struct) :: struct
def(clear_unknown_fields(msg)) do
struct!(msg, [{unknown_fields_name(), []}])
end
@spec syntax() :: atom
def(syntax()) do
:proto3
end
[
@spec(
default(atom) :: {:ok, boolean | integer | String.t() | binary | float} | {:error, atom}
),
[
def(default(:name)) do
{:ok, ""}
end,
def(default(:ast_node_id)) do
{:ok, ""}
end
],
def(default(_)) do
{:error, :no_such_field}
end
]
)
[]
end,
defmodule(CucumberMessages.Meta.CI) do
@moduledoc false
(
defstruct(name: "", url: "", git: nil, __uf__: [])
(
@spec encode(struct) :: {:ok, iodata} | {:error, any}
def(encode(msg)) do
try do
{:ok, encode!(msg)}
rescue
e ->
{:error, e}
end
end
@spec encode!(struct) :: iodata | no_return
def(encode!(msg)) do
[]
|> encode_name(msg)
|> encode_url(msg)
|> encode_git(msg)
|> encode_unknown_fields(msg)
end
[]
[
defp(encode_name(acc, msg)) do
field_value = msg.name()
if(field_value == "") do
acc
else
[acc, "\n", Protox.Encode.encode_string(field_value)]
end
end,
defp(encode_url(acc, msg)) do
field_value = msg.url()
if(field_value == "") do
acc
else
[acc, <<18>>, Protox.Encode.encode_string(field_value)]
end
end,
defp(encode_git(acc, msg)) do
field_value = msg.git()
if(field_value == nil) do
acc
else
[acc, <<26>>, Protox.Encode.encode_message(field_value)]
end
end
]
defp(encode_unknown_fields(acc, msg)) do
Enum.reduce(msg.__struct__.unknown_fields(msg), acc, fn {tag, wire_type, bytes}, acc ->
case(wire_type) do
0 ->
[acc, Protox.Encode.make_key_bytes(tag, :int32), bytes]
1 ->
[acc, Protox.Encode.make_key_bytes(tag, :double), bytes]
2 ->
len_bytes = bytes |> byte_size() |> Protox.Varint.encode()
[acc, Protox.Encode.make_key_bytes(tag, :packed), len_bytes, bytes]
5 ->
[acc, Protox.Encode.make_key_bytes(tag, :float), bytes]
end
end)
end
)
(
@spec decode(binary) :: {:ok, struct} | {:error, any}
def(decode(bytes)) do
try do
{:ok, decode!(bytes)}
rescue
Protox.IllegalTagError ->
{:error, :illegal_tag}
e in Protox.RequiredFieldsError ->
{:error, {:missing_fields, e.missing_fields}}
e in Protox.DecodingError ->
{:error, {e.reason, e.binary}}
e ->
{:error, e}
end
end
(
@spec decode!(binary) :: struct | no_return
def(decode!(bytes)) do
parse_key_value(bytes, struct(CucumberMessages.Meta.CI))
end
)
(
@spec parse_key_value(binary, struct) :: struct
defp(parse_key_value(<<>>, msg)) do
msg
end
defp(parse_key_value(bytes, msg)) do
{field, rest} =
case(Protox.Decode.parse_key(bytes)) do
{0, _, _} ->
raise(%Protox.IllegalTagError{})
{1, _, bytes} ->
{len, bytes} = Protox.Varint.decode(bytes)
<<delimited::binary-size(len), rest::binary>> = bytes
value = delimited
field = {:name, value}
{field, rest}
{2, _, bytes} ->
{len, bytes} = Protox.Varint.decode(bytes)
<<delimited::binary-size(len), rest::binary>> = bytes
value = delimited
field = {:url, value}
{field, rest}
{3, _, bytes} ->
{len, bytes} = Protox.Varint.decode(bytes)
<<delimited::binary-size(len), rest::binary>> = bytes
value = CucumberMessages.Meta.CI.Git.decode!(delimited)
field = {:git, Protox.Message.merge(msg.git(), value)}
{field, rest}
{tag, wire_type, rest} ->
{value, new_rest} = Protox.Decode.parse_unknown(tag, wire_type, rest)
field =
{msg.__struct__.unknown_fields_name,
[value | msg.__struct__.unknown_fields(msg)]}
{field, new_rest}
end
msg_updated = struct(msg, [field])
parse_key_value(rest, msg_updated)
end
)
[]
)
@spec defs() :: %{
required(non_neg_integer) => {atom, Protox.Types.kind(), Protox.Types.type()}
}
def(defs()) do
%{
1 => {:name, {:default, ""}, :string},
2 => {:url, {:default, ""}, :string},
3 => {:git, {:default, nil}, {:message, CucumberMessages.Meta.CI.Git}}
}
end
@spec defs_by_name() :: %{
required(atom) => {non_neg_integer, Protox.Types.kind(), Protox.Types.type()}
}
def(defs_by_name()) do
%{
git: {3, {:default, nil}, {:message, CucumberMessages.Meta.CI.Git}},
name: {1, {:default, ""}, :string},
url: {2, {:default, ""}, :string}
}
end
@spec required_fields() :: []
def(required_fields()) do
[]
end
@spec unknown_fields(struct) :: [{non_neg_integer, Protox.Types.tag(), binary}]
def(unknown_fields(msg)) do
msg.__uf__()
end
@spec unknown_fields_name() :: :__uf__
def(unknown_fields_name()) do
:__uf__
end
@spec clear_unknown_fields(struct) :: struct
def(clear_unknown_fields(msg)) do
struct!(msg, [{unknown_fields_name(), []}])
end
@spec syntax() :: atom
def(syntax()) do
:proto3
end
[
@spec(
default(atom) :: {:ok, boolean | integer | String.t() | binary | float} | {:error, atom}
),
[
def(default(:name)) do
{:ok, ""}
end,
def(default(:url)) do
{:ok, ""}
end,
def(default(:git)) do
{:ok, nil}
end
],
def(default(_)) do
{:error, :no_such_field}
end
]
)
[]
end,
defmodule(CucumberMessages.PickleStepArgument.PickleTable.PickleTableRow.PickleTableCell) do
@moduledoc false
(
defstruct(value: "", __uf__: [])
(
@spec encode(struct) :: {:ok, iodata} | {:error, any}
def(encode(msg)) do
try do
{:ok, encode!(msg)}
rescue
e ->
{:error, e}
end
end
@spec encode!(struct) :: iodata | no_return
def(encode!(msg)) do
[] |> encode_value(msg) |> encode_unknown_fields(msg)
end
[]
[
defp(encode_value(acc, msg)) do
field_value = msg.value()
if(field_value == "") do
acc
else
[acc, "\n", Protox.Encode.encode_string(field_value)]
end
end
]
defp(encode_unknown_fields(acc, msg)) do
Enum.reduce(msg.__struct__.unknown_fields(msg), acc, fn {tag, wire_type, bytes}, acc ->
case(wire_type) do
0 ->
[acc, Protox.Encode.make_key_bytes(tag, :int32), bytes]
1 ->
[acc, Protox.Encode.make_key_bytes(tag, :double), bytes]
2 ->
len_bytes = bytes |> byte_size() |> Protox.Varint.encode()
[acc, Protox.Encode.make_key_bytes(tag, :packed), len_bytes, bytes]
5 ->
[acc, Protox.Encode.make_key_bytes(tag, :float), bytes]
end
end)
end
)
(
@spec decode(binary) :: {:ok, struct} | {:error, any}
def(decode(bytes)) do
try do
{:ok, decode!(bytes)}
rescue
Protox.IllegalTagError ->
{:error, :illegal_tag}
e in Protox.RequiredFieldsError ->
{:error, {:missing_fields, e.missing_fields}}
e in Protox.DecodingError ->
{:error, {e.reason, e.binary}}
e ->
{:error, e}
end
end
(
@spec decode!(binary) :: struct | no_return
def(decode!(bytes)) do
parse_key_value(
bytes,
struct(
CucumberMessages.PickleStepArgument.PickleTable.PickleTableRow.PickleTableCell
)
)
end
)
(
@spec parse_key_value(binary, struct) :: struct
defp(parse_key_value(<<>>, msg)) do
msg
end
defp(parse_key_value(bytes, msg)) do
{field, rest} =
case(Protox.Decode.parse_key(bytes)) do
{0, _, _} ->
raise(%Protox.IllegalTagError{})
{1, _, bytes} ->
{len, bytes} = Protox.Varint.decode(bytes)
<<delimited::binary-size(len), rest::binary>> = bytes
value = delimited
field = {:value, value}
{field, rest}
{tag, wire_type, rest} ->
{value, new_rest} = Protox.Decode.parse_unknown(tag, wire_type, rest)
field =
{msg.__struct__.unknown_fields_name,
[value | msg.__struct__.unknown_fields(msg)]}
{field, new_rest}
end
msg_updated = struct(msg, [field])
parse_key_value(rest, msg_updated)
end
)
[]
)
@spec defs() :: %{
required(non_neg_integer) => {atom, Protox.Types.kind(), Protox.Types.type()}
}
def(defs()) do
%{1 => {:value, {:default, ""}, :string}}
end
@spec defs_by_name() :: %{
required(atom) => {non_neg_integer, Protox.Types.kind(), Protox.Types.type()}
}
def(defs_by_name()) do
%{value: {1, {:default, ""}, :string}}
end
@spec required_fields() :: []
def(required_fields()) do
[]
end
@spec unknown_fields(struct) :: [{non_neg_integer, Protox.Types.tag(), binary}]
def(unknown_fields(msg)) do
msg.__uf__()
end
@spec unknown_fields_name() :: :__uf__
def(unknown_fields_name()) do
:__uf__
end
@spec clear_unknown_fields(struct) :: struct
def(clear_unknown_fields(msg)) do
struct!(msg, [{unknown_fields_name(), []}])
end
@spec syntax() :: atom
def(syntax()) do
:proto3
end
[
@spec(
default(atom) :: {:ok, boolean | integer | String.t() | binary | float} | {:error, atom}
),
[
def(default(:value)) do
{:ok, ""}
end
],
def(default(_)) do
{:error, :no_such_field}
end
]
)
[]
end,
defmodule(CucumberMessages.Meta) do
@moduledoc false
(
defstruct(
protocol_version: "",
implementation: nil,
runtime: nil,
os: nil,
cpu: nil,
ci: nil,
__uf__: []
)
(
@spec encode(struct) :: {:ok, iodata} | {:error, any}
def(encode(msg)) do
try do
{:ok, encode!(msg)}
rescue
e ->
{:error, e}
end
end
@spec encode!(struct) :: iodata | no_return
def(encode!(msg)) do
[]
|> encode_protocol_version(msg)
|> encode_implementation(msg)
|> encode_runtime(msg)
|> encode_os(msg)
|> encode_cpu(msg)
|> encode_ci(msg)
|> encode_unknown_fields(msg)
end
[]
[
defp(encode_protocol_version(acc, msg)) do
field_value = msg.protocol_version()
if(field_value == "") do
acc
else
[acc, "\n", Protox.Encode.encode_string(field_value)]
end
end,
defp(encode_implementation(acc, msg)) do
field_value = msg.implementation()
if(field_value == nil) do
acc
else
[acc, <<18>>, Protox.Encode.encode_message(field_value)]
end
end,
defp(encode_runtime(acc, msg)) do
field_value = msg.runtime()
if(field_value == nil) do
acc
else
[acc, <<26>>, Protox.Encode.encode_message(field_value)]
end
end,
defp(encode_os(acc, msg)) do
field_value = msg.os()
if(field_value == nil) do
acc
else
[acc, "\"", Protox.Encode.encode_message(field_value)]
end
end,
defp(encode_cpu(acc, msg)) do
field_value = msg.cpu()
if(field_value == nil) do
acc
else
[acc, "*", Protox.Encode.encode_message(field_value)]
end
end,
defp(encode_ci(acc, msg)) do
field_value = msg.ci()
if(field_value == nil) do
acc
else
[acc, "2", Protox.Encode.encode_message(field_value)]
end
end
]
defp(encode_unknown_fields(acc, msg)) do
Enum.reduce(msg.__struct__.unknown_fields(msg), acc, fn {tag, wire_type, bytes}, acc ->
case(wire_type) do
0 ->
[acc, Protox.Encode.make_key_bytes(tag, :int32), bytes]
1 ->
[acc, Protox.Encode.make_key_bytes(tag, :double), bytes]
2 ->
len_bytes = bytes |> byte_size() |> Protox.Varint.encode()
[acc, Protox.Encode.make_key_bytes(tag, :packed), len_bytes, bytes]
5 ->
[acc, Protox.Encode.make_key_bytes(tag, :float), bytes]
end
end)
end
)
(
@spec decode(binary) :: {:ok, struct} | {:error, any}
def(decode(bytes)) do
try do
{:ok, decode!(bytes)}
rescue
Protox.IllegalTagError ->
{:error, :illegal_tag}
e in Protox.RequiredFieldsError ->
{:error, {:missing_fields, e.missing_fields}}
e in Protox.DecodingError ->
{:error, {e.reason, e.binary}}
e ->
{:error, e}
end
end
(
@spec decode!(binary) :: struct | no_return
def(decode!(bytes)) do
parse_key_value(bytes, struct(CucumberMessages.Meta))
end
)
(
@spec parse_key_value(binary, struct) :: struct
defp(parse_key_value(<<>>, msg)) do
msg
end
defp(parse_key_value(bytes, msg)) do
{field, rest} =
case(Protox.Decode.parse_key(bytes)) do
{0, _, _} ->
raise(%Protox.IllegalTagError{})
{1, _, bytes} ->
{len, bytes} = Protox.Varint.decode(bytes)
<<delimited::binary-size(len), rest::binary>> = bytes
value = delimited
field = {:protocol_version, value}
{field, rest}
{2, _, bytes} ->
{len, bytes} = Protox.Varint.decode(bytes)
<<delimited::binary-size(len), rest::binary>> = bytes
value = CucumberMessages.Meta.Product.decode!(delimited)
field = {:implementation, Protox.Message.merge(msg.implementation(), value)}
{field, rest}
{3, _, bytes} ->
{len, bytes} = Protox.Varint.decode(bytes)
<<delimited::binary-size(len), rest::binary>> = bytes
value = CucumberMessages.Meta.Product.decode!(delimited)
field = {:runtime, Protox.Message.merge(msg.runtime(), value)}
{field, rest}
{4, _, bytes} ->
{len, bytes} = Protox.Varint.decode(bytes)
<<delimited::binary-size(len), rest::binary>> = bytes
value = CucumberMessages.Meta.Product.decode!(delimited)
field = {:os, Protox.Message.merge(msg.os(), value)}
{field, rest}
{5, _, bytes} ->
{len, bytes} = Protox.Varint.decode(bytes)
<<delimited::binary-size(len), rest::binary>> = bytes
value = CucumberMessages.Meta.Product.decode!(delimited)
field = {:cpu, Protox.Message.merge(msg.cpu(), value)}
{field, rest}
{6, _, bytes} ->
{len, bytes} = Protox.Varint.decode(bytes)
<<delimited::binary-size(len), rest::binary>> = bytes
value = CucumberMessages.Meta.CI.decode!(delimited)
field = {:ci, Protox.Message.merge(msg.ci(), value)}
{field, rest}
{tag, wire_type, rest} ->
{value, new_rest} = Protox.Decode.parse_unknown(tag, wire_type, rest)
field =
{msg.__struct__.unknown_fields_name,
[value | msg.__struct__.unknown_fields(msg)]}
{field, new_rest}
end
msg_updated = struct(msg, [field])
parse_key_value(rest, msg_updated)
end
)
[]
)
@spec defs() :: %{
required(non_neg_integer) => {atom, Protox.Types.kind(), Protox.Types.type()}
}
def(defs()) do
%{
1 => {:protocol_version, {:default, ""}, :string},
2 => {:implementation, {:default, nil}, {:message, CucumberMessages.Meta.Product}},
3 => {:runtime, {:default, nil}, {:message, CucumberMessages.Meta.Product}},
4 => {:os, {:default, nil}, {:message, CucumberMessages.Meta.Product}},
5 => {:cpu, {:default, nil}, {:message, CucumberMessages.Meta.Product}},
6 => {:ci, {:default, nil}, {:message, CucumberMessages.Meta.CI}}
}
end
@spec defs_by_name() :: %{
required(atom) => {non_neg_integer, Protox.Types.kind(), Protox.Types.type()}
}
def(defs_by_name()) do
%{
ci: {6, {:default, nil}, {:message, CucumberMessages.Meta.CI}},
cpu: {5, {:default, nil}, {:message, CucumberMessages.Meta.Product}},
implementation: {2, {:default, nil}, {:message, CucumberMessages.Meta.Product}},
os: {4, {:default, nil}, {:message, CucumberMessages.Meta.Product}},
protocol_version: {1, {:default, ""}, :string},
runtime: {3, {:default, nil}, {:message, CucumberMessages.Meta.Product}}
}
end
@spec required_fields() :: []
def(required_fields()) do
[]
end
@spec unknown_fields(struct) :: [{non_neg_integer, Protox.Types.tag(), binary}]
def(unknown_fields(msg)) do
msg.__uf__()
end
@spec unknown_fields_name() :: :__uf__
def(unknown_fields_name()) do
:__uf__
end
@spec clear_unknown_fields(struct) :: struct
def(clear_unknown_fields(msg)) do
struct!(msg, [{unknown_fields_name(), []}])
end
@spec syntax() :: atom
def(syntax()) do
:proto3
end
[
@spec(
default(atom) :: {:ok, boolean | integer | String.t() | binary | float} | {:error, atom}
),
[
def(default(:protocol_version)) do
{:ok, ""}
end,
def(default(:implementation)) do
{:ok, nil}
end,
def(default(:runtime)) do
{:ok, nil}
end,
def(default(:os)) do
{:ok, nil}
end,
def(default(:cpu)) do
{:ok, nil}
end,
def(default(:ci)) do
{:ok, nil}
end
],
def(default(_)) do
{:error, :no_such_field}
end
]
)
[]
end,
defmodule(CucumberMessages.GherkinDocument.Feature.FeatureChild.RuleChild) do
@moduledoc false
(
defstruct(value: nil, __uf__: [])
(
@spec encode(struct) :: {:ok, iodata} | {:error, any}
def(encode(msg)) do
try do
{:ok, encode!(msg)}
rescue
e ->
{:error, e}
end
end
@spec encode!(struct) :: iodata | no_return
def(encode!(msg)) do
[] |> encode_value(msg) |> encode_unknown_fields(msg)
end
[
defp(encode_value(acc, msg)) do
case(msg.value()) do
nil ->
acc
{:background, _field_value} ->
encode_background(acc, msg)
{:scenario, _field_value} ->
encode_scenario(acc, msg)
end
end
]
[
defp(encode_background(acc, msg)) do
{_, field_value} = msg.value()
[acc, "\n", Protox.Encode.encode_message(field_value)]
end,
defp(encode_scenario(acc, msg)) do
{_, field_value} = msg.value()
[acc, <<18>>, Protox.Encode.encode_message(field_value)]
end
]
defp(encode_unknown_fields(acc, msg)) do
Enum.reduce(msg.__struct__.unknown_fields(msg), acc, fn {tag, wire_type, bytes}, acc ->
case(wire_type) do
0 ->
[acc, Protox.Encode.make_key_bytes(tag, :int32), bytes]
1 ->
[acc, Protox.Encode.make_key_bytes(tag, :double), bytes]
2 ->
len_bytes = bytes |> byte_size() |> Protox.Varint.encode()
[acc, Protox.Encode.make_key_bytes(tag, :packed), len_bytes, bytes]
5 ->
[acc, Protox.Encode.make_key_bytes(tag, :float), bytes]
end
end)
end
)
(
@spec decode(binary) :: {:ok, struct} | {:error, any}
def(decode(bytes)) do
try do
{:ok, decode!(bytes)}
rescue
Protox.IllegalTagError ->
{:error, :illegal_tag}
e in Protox.RequiredFieldsError ->
{:error, {:missing_fields, e.missing_fields}}
e in Protox.DecodingError ->
{:error, {e.reason, e.binary}}
e ->
{:error, e}
end
end
(
@spec decode!(binary) :: struct | no_return
def(decode!(bytes)) do
parse_key_value(
bytes,
struct(CucumberMessages.GherkinDocument.Feature.FeatureChild.RuleChild)
)
end
)
(
@spec parse_key_value(binary, struct) :: struct
defp(parse_key_value(<<>>, msg)) do
msg
end
defp(parse_key_value(bytes, msg)) do
{field, rest} =
case(Protox.Decode.parse_key(bytes)) do
{0, _, _} ->
raise(%Protox.IllegalTagError{})
{1, _, bytes} ->
{len, bytes} = Protox.Varint.decode(bytes)
<<delimited::binary-size(len), rest::binary>> = bytes
value = CucumberMessages.GherkinDocument.Feature.Background.decode!(delimited)
field =
case(msg.value()) do
{:background, previous_value} ->
{:value, {:background, Protox.Message.merge(previous_value, value)}}
_ ->
{:value, {:background, value}}
end
{field, rest}
{2, _, bytes} ->
{len, bytes} = Protox.Varint.decode(bytes)
<<delimited::binary-size(len), rest::binary>> = bytes
value = CucumberMessages.GherkinDocument.Feature.Scenario.decode!(delimited)
field =
case(msg.value()) do
{:scenario, previous_value} ->
{:value, {:scenario, Protox.Message.merge(previous_value, value)}}
_ ->
{:value, {:scenario, value}}
end
{field, rest}
{tag, wire_type, rest} ->
{value, new_rest} = Protox.Decode.parse_unknown(tag, wire_type, rest)
field =
{msg.__struct__.unknown_fields_name,
[value | msg.__struct__.unknown_fields(msg)]}
{field, new_rest}
end
msg_updated = struct(msg, [field])
parse_key_value(rest, msg_updated)
end
)
[]
)
@spec defs() :: %{
required(non_neg_integer) => {atom, Protox.Types.kind(), Protox.Types.type()}
}
def(defs()) do
%{
1 =>
{:background, {:oneof, :value},
{:message, CucumberMessages.GherkinDocument.Feature.Background}},
2 =>
{:scenario, {:oneof, :value},
{:message, CucumberMessages.GherkinDocument.Feature.Scenario}}
}
end
@spec defs_by_name() :: %{
required(atom) => {non_neg_integer, Protox.Types.kind(), Protox.Types.type()}
}
def(defs_by_name()) do
%{
background:
{1, {:oneof, :value}, {:message, CucumberMessages.GherkinDocument.Feature.Background}},
scenario:
{2, {:oneof, :value}, {:message, CucumberMessages.GherkinDocument.Feature.Scenario}}
}
end
@spec required_fields() :: []
def(required_fields()) do
[]
end
@spec unknown_fields(struct) :: [{non_neg_integer, Protox.Types.tag(), binary}]
def(unknown_fields(msg)) do
msg.__uf__()
end
@spec unknown_fields_name() :: :__uf__
def(unknown_fields_name()) do
:__uf__
end
@spec clear_unknown_fields(struct) :: struct
def(clear_unknown_fields(msg)) do
struct!(msg, [{unknown_fields_name(), []}])
end
@spec syntax() :: atom
def(syntax()) do
:proto3
end
[
@spec(
default(atom) :: {:ok, boolean | integer | String.t() | binary | float} | {:error, atom}
),
[
def(default(:background)) do
{:error, :no_default_value}
end,
def(default(:scenario)) do
{:error, :no_default_value}
end
],
def(default(_)) do
{:error, :no_such_field}
end
]
)
[]
end,
defmodule(CucumberMessages.GherkinDocument.Feature.FeatureChild.Rule) do
@moduledoc false
(
defstruct(
location: nil,
keyword: "",
name: "",
description: "",
children: [],
id: "",
__uf__: []
)
(
@spec encode(struct) :: {:ok, iodata} | {:error, any}
def(encode(msg)) do
try do
{:ok, encode!(msg)}
rescue
e ->
{:error, e}
end
end
@spec encode!(struct) :: iodata | no_return
def(encode!(msg)) do
[]
|> encode_location(msg)
|> encode_keyword(msg)
|> encode_name(msg)
|> encode_description(msg)
|> encode_children(msg)
|> encode_id(msg)
|> encode_unknown_fields(msg)
end
[]
[
defp(encode_location(acc, msg)) do
field_value = msg.location()
if(field_value == nil) do
acc
else
[acc, "\n", Protox.Encode.encode_message(field_value)]
end
end,
defp(encode_keyword(acc, msg)) do
field_value = msg.keyword()
if(field_value == "") do
acc
else
[acc, <<18>>, Protox.Encode.encode_string(field_value)]
end
end,
defp(encode_name(acc, msg)) do
field_value = msg.name()
if(field_value == "") do
acc
else
[acc, <<26>>, Protox.Encode.encode_string(field_value)]
end
end,
defp(encode_description(acc, msg)) do
field_value = msg.description()
if(field_value == "") do
acc
else
[acc, "\"", Protox.Encode.encode_string(field_value)]
end
end,
defp(encode_children(acc, msg)) do
case(msg.children()) do
[] ->
acc
values ->
[
acc,
Enum.reduce(values, [], fn value, acc ->
[acc, "*", Protox.Encode.encode_message(value)]
end)
]
end
end,
defp(encode_id(acc, msg)) do
field_value = msg.id()
if(field_value == "") do
acc
else
[acc, "2", Protox.Encode.encode_string(field_value)]
end
end
]
defp(encode_unknown_fields(acc, msg)) do
Enum.reduce(msg.__struct__.unknown_fields(msg), acc, fn {tag, wire_type, bytes}, acc ->
case(wire_type) do
0 ->
[acc, Protox.Encode.make_key_bytes(tag, :int32), bytes]
1 ->
[acc, Protox.Encode.make_key_bytes(tag, :double), bytes]
2 ->
len_bytes = bytes |> byte_size() |> Protox.Varint.encode()
[acc, Protox.Encode.make_key_bytes(tag, :packed), len_bytes, bytes]
5 ->
[acc, Protox.Encode.make_key_bytes(tag, :float), bytes]
end
end)
end
)
(
@spec decode(binary) :: {:ok, struct} | {:error, any}
def(decode(bytes)) do
try do
{:ok, decode!(bytes)}
rescue
Protox.IllegalTagError ->
{:error, :illegal_tag}
e in Protox.RequiredFieldsError ->
{:error, {:missing_fields, e.missing_fields}}
e in Protox.DecodingError ->
{:error, {e.reason, e.binary}}
e ->
{:error, e}
end
end
(
@spec decode!(binary) :: struct | no_return
def(decode!(bytes)) do
parse_key_value(
bytes,
struct(CucumberMessages.GherkinDocument.Feature.FeatureChild.Rule)
)
end
)
(
@spec parse_key_value(binary, struct) :: struct
defp(parse_key_value(<<>>, msg)) do
msg
end
defp(parse_key_value(bytes, msg)) do
{field, rest} =
case(Protox.Decode.parse_key(bytes)) do
{0, _, _} ->
raise(%Protox.IllegalTagError{})
{1, _, bytes} ->
{len, bytes} = Protox.Varint.decode(bytes)
<<delimited::binary-size(len), rest::binary>> = bytes
value = CucumberMessages.Location.decode!(delimited)
field = {:location, Protox.Message.merge(msg.location(), value)}
{field, rest}
{2, _, bytes} ->
{len, bytes} = Protox.Varint.decode(bytes)
<<delimited::binary-size(len), rest::binary>> = bytes
value = delimited
field = {:keyword, value}
{field, rest}
{3, _, bytes} ->
{len, bytes} = Protox.Varint.decode(bytes)
<<delimited::binary-size(len), rest::binary>> = bytes
value = delimited
field = {:name, value}
{field, rest}
{4, _, bytes} ->
{len, bytes} = Protox.Varint.decode(bytes)
<<delimited::binary-size(len), rest::binary>> = bytes
value = delimited
field = {:description, value}
{field, rest}
{5, _, bytes} ->
{len, bytes} = Protox.Varint.decode(bytes)
<<delimited::binary-size(len), rest::binary>> = bytes
value =
CucumberMessages.GherkinDocument.Feature.FeatureChild.RuleChild.decode!(
delimited
)
field = {:children, msg.children() ++ List.wrap(value)}
{field, rest}
{6, _, bytes} ->
{len, bytes} = Protox.Varint.decode(bytes)
<<delimited::binary-size(len), rest::binary>> = bytes
value = delimited
field = {:id, value}
{field, rest}
{tag, wire_type, rest} ->
{value, new_rest} = Protox.Decode.parse_unknown(tag, wire_type, rest)
field =
{msg.__struct__.unknown_fields_name,
[value | msg.__struct__.unknown_fields(msg)]}
{field, new_rest}
end
msg_updated = struct(msg, [field])
parse_key_value(rest, msg_updated)
end
)
[]
)
@spec defs() :: %{
required(non_neg_integer) => {atom, Protox.Types.kind(), Protox.Types.type()}
}
def(defs()) do
%{
1 => {:location, {:default, nil}, {:message, CucumberMessages.Location}},
2 => {:keyword, {:default, ""}, :string},
3 => {:name, {:default, ""}, :string},
4 => {:description, {:default, ""}, :string},
5 =>
{:children, :unpacked,
{:message, CucumberMessages.GherkinDocument.Feature.FeatureChild.RuleChild}},
6 => {:id, {:default, ""}, :string}
}
end
@spec defs_by_name() :: %{
required(atom) => {non_neg_integer, Protox.Types.kind(), Protox.Types.type()}
}
def(defs_by_name()) do
%{
children:
{5, :unpacked,
{:message, CucumberMessages.GherkinDocument.Feature.FeatureChild.RuleChild}},
description: {4, {:default, ""}, :string},
id: {6, {:default, ""}, :string},
keyword: {2, {:default, ""}, :string},
location: {1, {:default, nil}, {:message, CucumberMessages.Location}},
name: {3, {:default, ""}, :string}
}
end
@spec required_fields() :: []
def(required_fields()) do
[]
end
@spec unknown_fields(struct) :: [{non_neg_integer, Protox.Types.tag(), binary}]
def(unknown_fields(msg)) do
msg.__uf__()
end
@spec unknown_fields_name() :: :__uf__
def(unknown_fields_name()) do
:__uf__
end
@spec clear_unknown_fields(struct) :: struct
def(clear_unknown_fields(msg)) do
struct!(msg, [{unknown_fields_name(), []}])
end
@spec syntax() :: atom
def(syntax()) do
:proto3
end
[
@spec(
default(atom) :: {:ok, boolean | integer | String.t() | binary | float} | {:error, atom}
),
[
def(default(:location)) do
{:ok, nil}
end,
def(default(:keyword)) do
{:ok, ""}
end,
def(default(:name)) do
{:ok, ""}
end,
def(default(:description)) do
{:ok, ""}
end,
def(default(:children)) do
{:error, :no_default_value}
end,
def(default(:id)) do
{:ok, ""}
end
],
def(default(_)) do
{:error, :no_such_field}
end
]
)
[]
end,
defmodule(CucumberMessages.UndefinedParameterType) do
@moduledoc false
(
defstruct(name: "", expression: "", __uf__: [])
(
@spec encode(struct) :: {:ok, iodata} | {:error, any}
def(encode(msg)) do
try do
{:ok, encode!(msg)}
rescue
e ->
{:error, e}
end
end
@spec encode!(struct) :: iodata | no_return
def(encode!(msg)) do
[] |> encode_name(msg) |> encode_expression(msg) |> encode_unknown_fields(msg)
end
[]
[
defp(encode_name(acc, msg)) do
field_value = msg.name()
if(field_value == "") do
acc
else
[acc, "\n", Protox.Encode.encode_string(field_value)]
end
end,
defp(encode_expression(acc, msg)) do
field_value = msg.expression()
if(field_value == "") do
acc
else
[acc, <<18>>, Protox.Encode.encode_string(field_value)]
end
end
]
defp(encode_unknown_fields(acc, msg)) do
Enum.reduce(msg.__struct__.unknown_fields(msg), acc, fn {tag, wire_type, bytes}, acc ->
case(wire_type) do
0 ->
[acc, Protox.Encode.make_key_bytes(tag, :int32), bytes]
1 ->
[acc, Protox.Encode.make_key_bytes(tag, :double), bytes]
2 ->
len_bytes = bytes |> byte_size() |> Protox.Varint.encode()
[acc, Protox.Encode.make_key_bytes(tag, :packed), len_bytes, bytes]
5 ->
[acc, Protox.Encode.make_key_bytes(tag, :float), bytes]
end
end)
end
)
(
@spec decode(binary) :: {:ok, struct} | {:error, any}
def(decode(bytes)) do
try do
{:ok, decode!(bytes)}
rescue
Protox.IllegalTagError ->
{:error, :illegal_tag}
e in Protox.RequiredFieldsError ->
{:error, {:missing_fields, e.missing_fields}}
e in Protox.DecodingError ->
{:error, {e.reason, e.binary}}
e ->
{:error, e}
end
end
(
@spec decode!(binary) :: struct | no_return
def(decode!(bytes)) do
parse_key_value(bytes, struct(CucumberMessages.UndefinedParameterType))
end
)
(
@spec parse_key_value(binary, struct) :: struct
defp(parse_key_value(<<>>, msg)) do
msg
end
defp(parse_key_value(bytes, msg)) do
{field, rest} =
case(Protox.Decode.parse_key(bytes)) do
{0, _, _} ->
raise(%Protox.IllegalTagError{})
{1, _, bytes} ->
{len, bytes} = Protox.Varint.decode(bytes)
<<delimited::binary-size(len), rest::binary>> = bytes
value = delimited
field = {:name, value}
{field, rest}
{2, _, bytes} ->
{len, bytes} = Protox.Varint.decode(bytes)
<<delimited::binary-size(len), rest::binary>> = bytes
value = delimited
field = {:expression, value}
{field, rest}
{tag, wire_type, rest} ->
{value, new_rest} = Protox.Decode.parse_unknown(tag, wire_type, rest)
field =
{msg.__struct__.unknown_fields_name,
[value | msg.__struct__.unknown_fields(msg)]}
{field, new_rest}
end
msg_updated = struct(msg, [field])
parse_key_value(rest, msg_updated)
end
)
[]
)
@spec defs() :: %{
required(non_neg_integer) => {atom, Protox.Types.kind(), Protox.Types.type()}
}
def(defs()) do
%{1 => {:name, {:default, ""}, :string}, 2 => {:expression, {:default, ""}, :string}}
end
@spec defs_by_name() :: %{
required(atom) => {non_neg_integer, Protox.Types.kind(), Protox.Types.type()}
}
def(defs_by_name()) do
%{expression: {2, {:default, ""}, :string}, name: {1, {:default, ""}, :string}}
end
@spec required_fields() :: []
def(required_fields()) do
[]
end
@spec unknown_fields(struct) :: [{non_neg_integer, Protox.Types.tag(), binary}]
def(unknown_fields(msg)) do
msg.__uf__()
end
@spec unknown_fields_name() :: :__uf__
def(unknown_fields_name()) do
:__uf__
end
@spec clear_unknown_fields(struct) :: struct
def(clear_unknown_fields(msg)) do
struct!(msg, [{unknown_fields_name(), []}])
end
@spec syntax() :: atom
def(syntax()) do
:proto3
end
[
@spec(
default(atom) :: {:ok, boolean | integer | String.t() | binary | float} | {:error, atom}
),
[
def(default(:name)) do
{:ok, ""}
end,
def(default(:expression)) do
{:ok, ""}
end
],
def(default(_)) do
{:error, :no_such_field}
end
]
)
[]
end,
defmodule(CucumberMessages.TestCase.TestStep.StepMatchArgumentsList) do
@moduledoc false
(
defstruct(step_match_arguments: [], __uf__: [])
(
@spec encode(struct) :: {:ok, iodata} | {:error, any}
def(encode(msg)) do
try do
{:ok, encode!(msg)}
rescue
e ->
{:error, e}
end
end
@spec encode!(struct) :: iodata | no_return
def(encode!(msg)) do
[] |> encode_step_match_arguments(msg) |> encode_unknown_fields(msg)
end
[]
[
defp(encode_step_match_arguments(acc, msg)) do
case(msg.step_match_arguments()) do
[] ->
acc
values ->
[
acc,
Enum.reduce(values, [], fn value, acc ->
[acc, "\n", Protox.Encode.encode_message(value)]
end)
]
end
end
]
defp(encode_unknown_fields(acc, msg)) do
Enum.reduce(msg.__struct__.unknown_fields(msg), acc, fn {tag, wire_type, bytes}, acc ->
case(wire_type) do
0 ->
[acc, Protox.Encode.make_key_bytes(tag, :int32), bytes]
1 ->
[acc, Protox.Encode.make_key_bytes(tag, :double), bytes]
2 ->
len_bytes = bytes |> byte_size() |> Protox.Varint.encode()
[acc, Protox.Encode.make_key_bytes(tag, :packed), len_bytes, bytes]
5 ->
[acc, Protox.Encode.make_key_bytes(tag, :float), bytes]
end
end)
end
)
(
@spec decode(binary) :: {:ok, struct} | {:error, any}
def(decode(bytes)) do
try do
{:ok, decode!(bytes)}
rescue
Protox.IllegalTagError ->
{:error, :illegal_tag}
e in Protox.RequiredFieldsError ->
{:error, {:missing_fields, e.missing_fields}}
e in Protox.DecodingError ->
{:error, {e.reason, e.binary}}
e ->
{:error, e}
end
end
(
@spec decode!(binary) :: struct | no_return
def(decode!(bytes)) do
parse_key_value(
bytes,
struct(CucumberMessages.TestCase.TestStep.StepMatchArgumentsList)
)
end
)
(
@spec parse_key_value(binary, struct) :: struct
defp(parse_key_value(<<>>, msg)) do
msg
end
defp(parse_key_value(bytes, msg)) do
{field, rest} =
case(Protox.Decode.parse_key(bytes)) do
{0, _, _} ->
raise(%Protox.IllegalTagError{})
{1, _, bytes} ->
{len, bytes} = Protox.Varint.decode(bytes)
<<delimited::binary-size(len), rest::binary>> = bytes
value =
CucumberMessages.TestCase.TestStep.StepMatchArgumentsList.StepMatchArgument.decode!(
delimited
)
field = {:step_match_arguments, msg.step_match_arguments() ++ List.wrap(value)}
{field, rest}
{tag, wire_type, rest} ->
{value, new_rest} = Protox.Decode.parse_unknown(tag, wire_type, rest)
field =
{msg.__struct__.unknown_fields_name,
[value | msg.__struct__.unknown_fields(msg)]}
{field, new_rest}
end
msg_updated = struct(msg, [field])
parse_key_value(rest, msg_updated)
end
)
[]
)
@spec defs() :: %{
required(non_neg_integer) => {atom, Protox.Types.kind(), Protox.Types.type()}
}
def(defs()) do
%{
1 =>
{:step_match_arguments, :unpacked,
{:message,
CucumberMessages.TestCase.TestStep.StepMatchArgumentsList.StepMatchArgument}}
}
end
@spec defs_by_name() :: %{
required(atom) => {non_neg_integer, Protox.Types.kind(), Protox.Types.type()}
}
def(defs_by_name()) do
%{
step_match_arguments:
{1, :unpacked,
{:message,
CucumberMessages.TestCase.TestStep.StepMatchArgumentsList.StepMatchArgument}}
}
end
@spec required_fields() :: []
def(required_fields()) do
[]
end
@spec unknown_fields(struct) :: [{non_neg_integer, Protox.Types.tag(), binary}]
def(unknown_fields(msg)) do
msg.__uf__()
end
@spec unknown_fields_name() :: :__uf__
def(unknown_fields_name()) do
:__uf__
end
@spec clear_unknown_fields(struct) :: struct
def(clear_unknown_fields(msg)) do
struct!(msg, [{unknown_fields_name(), []}])
end
@spec syntax() :: atom
def(syntax()) do
:proto3
end
[
@spec(
default(atom) :: {:ok, boolean | integer | String.t() | binary | float} | {:error, atom}
),
[
def(default(:step_match_arguments)) do
{:error, :no_default_value}
end
],
def(default(_)) do
{:error, :no_such_field}
end
]
)
[]
end,
defmodule(CucumberMessages.GherkinDocument.Feature) do
@moduledoc false
(
defstruct(
location: nil,
tags: [],
language: "",
keyword: "",
name: "",
description: "",
children: [],
__uf__: []
)
(
@spec encode(struct) :: {:ok, iodata} | {:error, any}
def(encode(msg)) do
try do
{:ok, encode!(msg)}
rescue
e ->
{:error, e}
end
end
@spec encode!(struct) :: iodata | no_return
def(encode!(msg)) do
[]
|> encode_location(msg)
|> encode_tags(msg)
|> encode_language(msg)
|> encode_keyword(msg)
|> encode_name(msg)
|> encode_description(msg)
|> encode_children(msg)
|> encode_unknown_fields(msg)
end
[]
[
defp(encode_location(acc, msg)) do
field_value = msg.location()
if(field_value == nil) do
acc
else
[acc, "\n", Protox.Encode.encode_message(field_value)]
end
end,
defp(encode_tags(acc, msg)) do
case(msg.tags()) do
[] ->
acc
values ->
[
acc,
Enum.reduce(values, [], fn value, acc ->
[acc, <<18>>, Protox.Encode.encode_message(value)]
end)
]
end
end,
defp(encode_language(acc, msg)) do
field_value = msg.language()
if(field_value == "") do
acc
else
[acc, <<26>>, Protox.Encode.encode_string(field_value)]
end
end,
defp(encode_keyword(acc, msg)) do
field_value = msg.keyword()
if(field_value == "") do
acc
else
[acc, "\"", Protox.Encode.encode_string(field_value)]
end
end,
defp(encode_name(acc, msg)) do
field_value = msg.name()
if(field_value == "") do
acc
else
[acc, "*", Protox.Encode.encode_string(field_value)]
end
end,
defp(encode_description(acc, msg)) do
field_value = msg.description()
if(field_value == "") do
acc
else
[acc, "2", Protox.Encode.encode_string(field_value)]
end
end,
defp(encode_children(acc, msg)) do
case(msg.children()) do
[] ->
acc
values ->
[
acc,
Enum.reduce(values, [], fn value, acc ->
[acc, ":", Protox.Encode.encode_message(value)]
end)
]
end
end
]
defp(encode_unknown_fields(acc, msg)) do
Enum.reduce(msg.__struct__.unknown_fields(msg), acc, fn {tag, wire_type, bytes}, acc ->
case(wire_type) do
0 ->
[acc, Protox.Encode.make_key_bytes(tag, :int32), bytes]
1 ->
[acc, Protox.Encode.make_key_bytes(tag, :double), bytes]
2 ->
len_bytes = bytes |> byte_size() |> Protox.Varint.encode()
[acc, Protox.Encode.make_key_bytes(tag, :packed), len_bytes, bytes]
5 ->
[acc, Protox.Encode.make_key_bytes(tag, :float), bytes]
end
end)
end
)
(
@spec decode(binary) :: {:ok, struct} | {:error, any}
def(decode(bytes)) do
try do
{:ok, decode!(bytes)}
rescue
Protox.IllegalTagError ->
{:error, :illegal_tag}
e in Protox.RequiredFieldsError ->
{:error, {:missing_fields, e.missing_fields}}
e in Protox.DecodingError ->
{:error, {e.reason, e.binary}}
e ->
{:error, e}
end
end
(
@spec decode!(binary) :: struct | no_return
def(decode!(bytes)) do
parse_key_value(bytes, struct(CucumberMessages.GherkinDocument.Feature))
end
)
(
@spec parse_key_value(binary, struct) :: struct
defp(parse_key_value(<<>>, msg)) do
msg
end
defp(parse_key_value(bytes, msg)) do
{field, rest} =
case(Protox.Decode.parse_key(bytes)) do
{0, _, _} ->
raise(%Protox.IllegalTagError{})
{1, _, bytes} ->
{len, bytes} = Protox.Varint.decode(bytes)
<<delimited::binary-size(len), rest::binary>> = bytes
value = CucumberMessages.Location.decode!(delimited)
field = {:location, Protox.Message.merge(msg.location(), value)}
{field, rest}
{2, _, bytes} ->
{len, bytes} = Protox.Varint.decode(bytes)
<<delimited::binary-size(len), rest::binary>> = bytes
value = CucumberMessages.GherkinDocument.Feature.Tag.decode!(delimited)
field = {:tags, msg.tags() ++ List.wrap(value)}
{field, rest}
{3, _, bytes} ->
{len, bytes} = Protox.Varint.decode(bytes)
<<delimited::binary-size(len), rest::binary>> = bytes
value = delimited
field = {:language, value}
{field, rest}
{4, _, bytes} ->
{len, bytes} = Protox.Varint.decode(bytes)
<<delimited::binary-size(len), rest::binary>> = bytes
value = delimited
field = {:keyword, value}
{field, rest}
{5, _, bytes} ->
{len, bytes} = Protox.Varint.decode(bytes)
<<delimited::binary-size(len), rest::binary>> = bytes
value = delimited
field = {:name, value}
{field, rest}
{6, _, bytes} ->
{len, bytes} = Protox.Varint.decode(bytes)
<<delimited::binary-size(len), rest::binary>> = bytes
value = delimited
field = {:description, value}
{field, rest}
{7, _, bytes} ->
{len, bytes} = Protox.Varint.decode(bytes)
<<delimited::binary-size(len), rest::binary>> = bytes
value = CucumberMessages.GherkinDocument.Feature.FeatureChild.decode!(delimited)
field = {:children, msg.children() ++ List.wrap(value)}
{field, rest}
{tag, wire_type, rest} ->
{value, new_rest} = Protox.Decode.parse_unknown(tag, wire_type, rest)
field =
{msg.__struct__.unknown_fields_name,
[value | msg.__struct__.unknown_fields(msg)]}
{field, new_rest}
end
msg_updated = struct(msg, [field])
parse_key_value(rest, msg_updated)
end
)
[]
)
@spec defs() :: %{
required(non_neg_integer) => {atom, Protox.Types.kind(), Protox.Types.type()}
}
def(defs()) do
%{
1 => {:location, {:default, nil}, {:message, CucumberMessages.Location}},
2 => {:tags, :unpacked, {:message, CucumberMessages.GherkinDocument.Feature.Tag}},
3 => {:language, {:default, ""}, :string},
4 => {:keyword, {:default, ""}, :string},
5 => {:name, {:default, ""}, :string},
6 => {:description, {:default, ""}, :string},
7 =>
{:children, :unpacked,
{:message, CucumberMessages.GherkinDocument.Feature.FeatureChild}}
}
end
@spec defs_by_name() :: %{
required(atom) => {non_neg_integer, Protox.Types.kind(), Protox.Types.type()}
}
def(defs_by_name()) do
%{
children:
{7, :unpacked, {:message, CucumberMessages.GherkinDocument.Feature.FeatureChild}},
description: {6, {:default, ""}, :string},
keyword: {4, {:default, ""}, :string},
language: {3, {:default, ""}, :string},
location: {1, {:default, nil}, {:message, CucumberMessages.Location}},
name: {5, {:default, ""}, :string},
tags: {2, :unpacked, {:message, CucumberMessages.GherkinDocument.Feature.Tag}}
}
end
@spec required_fields() :: []
def(required_fields()) do
[]
end
@spec unknown_fields(struct) :: [{non_neg_integer, Protox.Types.tag(), binary}]
def(unknown_fields(msg)) do
msg.__uf__()
end
@spec unknown_fields_name() :: :__uf__
def(unknown_fields_name()) do
:__uf__
end
@spec clear_unknown_fields(struct) :: struct
def(clear_unknown_fields(msg)) do
struct!(msg, [{unknown_fields_name(), []}])
end
@spec syntax() :: atom
def(syntax()) do
:proto3
end
[
@spec(
default(atom) :: {:ok, boolean | integer | String.t() | binary | float} | {:error, atom}
),
[
def(default(:location)) do
{:ok, nil}
end,
def(default(:tags)) do
{:error, :no_default_value}
end,
def(default(:language)) do
{:ok, ""}
end,
def(default(:keyword)) do
{:ok, ""}
end,
def(default(:name)) do
{:ok, ""}
end,
def(default(:description)) do
{:ok, ""}
end,
def(default(:children)) do
{:error, :no_default_value}
end
],
def(default(_)) do
{:error, :no_such_field}
end
]
)
[]
end,
defmodule(CucumberMessages.GherkinDocument.Comment) do
@moduledoc false
(
defstruct(location: nil, text: "", __uf__: [])
(
@spec encode(struct) :: {:ok, iodata} | {:error, any}
def(encode(msg)) do
try do
{:ok, encode!(msg)}
rescue
e ->
{:error, e}
end
end
@spec encode!(struct) :: iodata | no_return
def(encode!(msg)) do
[] |> encode_location(msg) |> encode_text(msg) |> encode_unknown_fields(msg)
end
[]
[
defp(encode_location(acc, msg)) do
field_value = msg.location()
if(field_value == nil) do
acc
else
[acc, "\n", Protox.Encode.encode_message(field_value)]
end
end,
defp(encode_text(acc, msg)) do
field_value = msg.text()
if(field_value == "") do
acc
else
[acc, <<18>>, Protox.Encode.encode_string(field_value)]
end
end
]
defp(encode_unknown_fields(acc, msg)) do
Enum.reduce(msg.__struct__.unknown_fields(msg), acc, fn {tag, wire_type, bytes}, acc ->
case(wire_type) do
0 ->
[acc, Protox.Encode.make_key_bytes(tag, :int32), bytes]
1 ->
[acc, Protox.Encode.make_key_bytes(tag, :double), bytes]
2 ->
len_bytes = bytes |> byte_size() |> Protox.Varint.encode()
[acc, Protox.Encode.make_key_bytes(tag, :packed), len_bytes, bytes]
5 ->
[acc, Protox.Encode.make_key_bytes(tag, :float), bytes]
end
end)
end
)
(
@spec decode(binary) :: {:ok, struct} | {:error, any}
def(decode(bytes)) do
try do
{:ok, decode!(bytes)}
rescue
Protox.IllegalTagError ->
{:error, :illegal_tag}
e in Protox.RequiredFieldsError ->
{:error, {:missing_fields, e.missing_fields}}
e in Protox.DecodingError ->
{:error, {e.reason, e.binary}}
e ->
{:error, e}
end
end
(
@spec decode!(binary) :: struct | no_return
def(decode!(bytes)) do
parse_key_value(bytes, struct(CucumberMessages.GherkinDocument.Comment))
end
)
(
@spec parse_key_value(binary, struct) :: struct
defp(parse_key_value(<<>>, msg)) do
msg
end
defp(parse_key_value(bytes, msg)) do
{field, rest} =
case(Protox.Decode.parse_key(bytes)) do
{0, _, _} ->
raise(%Protox.IllegalTagError{})
{1, _, bytes} ->
{len, bytes} = Protox.Varint.decode(bytes)
<<delimited::binary-size(len), rest::binary>> = bytes
value = CucumberMessages.Location.decode!(delimited)
field = {:location, Protox.Message.merge(msg.location(), value)}
{field, rest}
{2, _, bytes} ->
{len, bytes} = Protox.Varint.decode(bytes)
<<delimited::binary-size(len), rest::binary>> = bytes
value = delimited
field = {:text, value}
{field, rest}
{tag, wire_type, rest} ->
{value, new_rest} = Protox.Decode.parse_unknown(tag, wire_type, rest)
field =
{msg.__struct__.unknown_fields_name,
[value | msg.__struct__.unknown_fields(msg)]}
{field, new_rest}
end
msg_updated = struct(msg, [field])
parse_key_value(rest, msg_updated)
end
)
[]
)
@spec defs() :: %{
required(non_neg_integer) => {atom, Protox.Types.kind(), Protox.Types.type()}
}
def(defs()) do
%{
1 => {:location, {:default, nil}, {:message, CucumberMessages.Location}},
2 => {:text, {:default, ""}, :string}
}
end
@spec defs_by_name() :: %{
required(atom) => {non_neg_integer, Protox.Types.kind(), Protox.Types.type()}
}
def(defs_by_name()) do
%{
location: {1, {:default, nil}, {:message, CucumberMessages.Location}},
text: {2, {:default, ""}, :string}
}
end
@spec required_fields() :: []
def(required_fields()) do
[]
end
@spec unknown_fields(struct) :: [{non_neg_integer, Protox.Types.tag(), binary}]
def(unknown_fields(msg)) do
msg.__uf__()
end
@spec unknown_fields_name() :: :__uf__
def(unknown_fields_name()) do
:__uf__
end
@spec clear_unknown_fields(struct) :: struct
def(clear_unknown_fields(msg)) do
struct!(msg, [{unknown_fields_name(), []}])
end
@spec syntax() :: atom
def(syntax()) do
:proto3
end
[
@spec(
default(atom) :: {:ok, boolean | integer | String.t() | binary | float} | {:error, atom}
),
[
def(default(:location)) do
{:ok, nil}
end,
def(default(:text)) do
{:ok, ""}
end
],
def(default(_)) do
{:error, :no_such_field}
end
]
)
[]
end,
defmodule(CucumberMessages.StepDefinition.StepDefinitionPattern) do
@moduledoc false
(
defstruct(source: "", type: :CUCUMBER_EXPRESSION, __uf__: [])
(
@spec encode(struct) :: {:ok, iodata} | {:error, any}
def(encode(msg)) do
try do
{:ok, encode!(msg)}
rescue
e ->
{:error, e}
end
end
@spec encode!(struct) :: iodata | no_return
def(encode!(msg)) do
[] |> encode_source(msg) |> encode_type(msg) |> encode_unknown_fields(msg)
end
[]
[
defp(encode_source(acc, msg)) do
field_value = msg.source()
if(field_value == "") do
acc
else
[acc, "\n", Protox.Encode.encode_string(field_value)]
end
end,
defp(encode_type(acc, msg)) do
field_value = msg.type()
if(field_value == :CUCUMBER_EXPRESSION) do
acc
else
[
acc,
<<16>>,
field_value
|> CucumberMessages.StepDefinition.StepDefinitionPattern.StepDefinitionPatternType.encode()
|> Protox.Encode.encode_enum()
]
end
end
]
defp(encode_unknown_fields(acc, msg)) do
Enum.reduce(msg.__struct__.unknown_fields(msg), acc, fn {tag, wire_type, bytes}, acc ->
case(wire_type) do
0 ->
[acc, Protox.Encode.make_key_bytes(tag, :int32), bytes]
1 ->
[acc, Protox.Encode.make_key_bytes(tag, :double), bytes]
2 ->
len_bytes = bytes |> byte_size() |> Protox.Varint.encode()
[acc, Protox.Encode.make_key_bytes(tag, :packed), len_bytes, bytes]
5 ->
[acc, Protox.Encode.make_key_bytes(tag, :float), bytes]
end
end)
end
)
(
@spec decode(binary) :: {:ok, struct} | {:error, any}
def(decode(bytes)) do
try do
{:ok, decode!(bytes)}
rescue
Protox.IllegalTagError ->
{:error, :illegal_tag}
e in Protox.RequiredFieldsError ->
{:error, {:missing_fields, e.missing_fields}}
e in Protox.DecodingError ->
{:error, {e.reason, e.binary}}
e ->
{:error, e}
end
end
(
@spec decode!(binary) :: struct | no_return
def(decode!(bytes)) do
parse_key_value(bytes, struct(CucumberMessages.StepDefinition.StepDefinitionPattern))
end
)
(
@spec parse_key_value(binary, struct) :: struct
defp(parse_key_value(<<>>, msg)) do
msg
end
defp(parse_key_value(bytes, msg)) do
{field, rest} =
case(Protox.Decode.parse_key(bytes)) do
{0, _, _} ->
raise(%Protox.IllegalTagError{})
{1, _, bytes} ->
{len, bytes} = Protox.Varint.decode(bytes)
<<delimited::binary-size(len), rest::binary>> = bytes
value = delimited
field = {:source, value}
{field, rest}
{2, _, bytes} ->
{value, rest} =
Protox.Decode.parse_enum(
bytes,
CucumberMessages.StepDefinition.StepDefinitionPattern.StepDefinitionPatternType
)
field = {:type, value}
{field, rest}
{tag, wire_type, rest} ->
{value, new_rest} = Protox.Decode.parse_unknown(tag, wire_type, rest)
field =
{msg.__struct__.unknown_fields_name,
[value | msg.__struct__.unknown_fields(msg)]}
{field, new_rest}
end
msg_updated = struct(msg, [field])
parse_key_value(rest, msg_updated)
end
)
[]
)
@spec defs() :: %{
required(non_neg_integer) => {atom, Protox.Types.kind(), Protox.Types.type()}
}
def(defs()) do
%{
1 => {:source, {:default, ""}, :string},
2 =>
{:type, {:default, :CUCUMBER_EXPRESSION},
{:enum,
CucumberMessages.StepDefinition.StepDefinitionPattern.StepDefinitionPatternType}}
}
end
@spec defs_by_name() :: %{
required(atom) => {non_neg_integer, Protox.Types.kind(), Protox.Types.type()}
}
def(defs_by_name()) do
%{
source: {1, {:default, ""}, :string},
type:
{2, {:default, :CUCUMBER_EXPRESSION},
{:enum,
CucumberMessages.StepDefinition.StepDefinitionPattern.StepDefinitionPatternType}}
}
end
@spec required_fields() :: []
def(required_fields()) do
[]
end
@spec unknown_fields(struct) :: [{non_neg_integer, Protox.Types.tag(), binary}]
def(unknown_fields(msg)) do
msg.__uf__()
end
@spec unknown_fields_name() :: :__uf__
def(unknown_fields_name()) do
:__uf__
end
@spec clear_unknown_fields(struct) :: struct
def(clear_unknown_fields(msg)) do
struct!(msg, [{unknown_fields_name(), []}])
end
@spec syntax() :: atom
def(syntax()) do
:proto3
end
[
@spec(
default(atom) :: {:ok, boolean | integer | String.t() | binary | float} | {:error, atom}
),
[
def(default(:source)) do
{:ok, ""}
end,
def(default(:type)) do
{:ok, :CUCUMBER_EXPRESSION}
end
],
def(default(_)) do
{:error, :no_such_field}
end
]
)
[]
end,
defmodule(CucumberMessages.GherkinDocument.Feature.Tag) do
@moduledoc false
(
defstruct(location: nil, name: "", id: "", __uf__: [])
(
@spec encode(struct) :: {:ok, iodata} | {:error, any}
def(encode(msg)) do
try do
{:ok, encode!(msg)}
rescue
e ->
{:error, e}
end
end
@spec encode!(struct) :: iodata | no_return
def(encode!(msg)) do
[]
|> encode_location(msg)
|> encode_name(msg)
|> encode_id(msg)
|> encode_unknown_fields(msg)
end
[]
[
defp(encode_location(acc, msg)) do
field_value = msg.location()
if(field_value == nil) do
acc
else
[acc, "\n", Protox.Encode.encode_message(field_value)]
end
end,
defp(encode_name(acc, msg)) do
field_value = msg.name()
if(field_value == "") do
acc
else
[acc, <<18>>, Protox.Encode.encode_string(field_value)]
end
end,
defp(encode_id(acc, msg)) do
field_value = msg.id()
if(field_value == "") do
acc
else
[acc, <<26>>, Protox.Encode.encode_string(field_value)]
end
end
]
defp(encode_unknown_fields(acc, msg)) do
Enum.reduce(msg.__struct__.unknown_fields(msg), acc, fn {tag, wire_type, bytes}, acc ->
case(wire_type) do
0 ->
[acc, Protox.Encode.make_key_bytes(tag, :int32), bytes]
1 ->
[acc, Protox.Encode.make_key_bytes(tag, :double), bytes]
2 ->
len_bytes = bytes |> byte_size() |> Protox.Varint.encode()
[acc, Protox.Encode.make_key_bytes(tag, :packed), len_bytes, bytes]
5 ->
[acc, Protox.Encode.make_key_bytes(tag, :float), bytes]
end
end)
end
)
(
@spec decode(binary) :: {:ok, struct} | {:error, any}
def(decode(bytes)) do
try do
{:ok, decode!(bytes)}
rescue
Protox.IllegalTagError ->
{:error, :illegal_tag}
e in Protox.RequiredFieldsError ->
{:error, {:missing_fields, e.missing_fields}}
e in Protox.DecodingError ->
{:error, {e.reason, e.binary}}
e ->
{:error, e}
end
end
(
@spec decode!(binary) :: struct | no_return
def(decode!(bytes)) do
parse_key_value(bytes, struct(CucumberMessages.GherkinDocument.Feature.Tag))
end
)
(
@spec parse_key_value(binary, struct) :: struct
defp(parse_key_value(<<>>, msg)) do
msg
end
defp(parse_key_value(bytes, msg)) do
{field, rest} =
case(Protox.Decode.parse_key(bytes)) do
{0, _, _} ->
raise(%Protox.IllegalTagError{})
{1, _, bytes} ->
{len, bytes} = Protox.Varint.decode(bytes)
<<delimited::binary-size(len), rest::binary>> = bytes
value = CucumberMessages.Location.decode!(delimited)
field = {:location, Protox.Message.merge(msg.location(), value)}
{field, rest}
{2, _, bytes} ->
{len, bytes} = Protox.Varint.decode(bytes)
<<delimited::binary-size(len), rest::binary>> = bytes
value = delimited
field = {:name, value}
{field, rest}
{3, _, bytes} ->
{len, bytes} = Protox.Varint.decode(bytes)
<<delimited::binary-size(len), rest::binary>> = bytes
value = delimited
field = {:id, value}
{field, rest}
{tag, wire_type, rest} ->
{value, new_rest} = Protox.Decode.parse_unknown(tag, wire_type, rest)
field =
{msg.__struct__.unknown_fields_name,
[value | msg.__struct__.unknown_fields(msg)]}
{field, new_rest}
end
msg_updated = struct(msg, [field])
parse_key_value(rest, msg_updated)
end
)
[]
)
@spec defs() :: %{
required(non_neg_integer) => {atom, Protox.Types.kind(), Protox.Types.type()}
}
def(defs()) do
%{
1 => {:location, {:default, nil}, {:message, CucumberMessages.Location}},
2 => {:name, {:default, ""}, :string},
3 => {:id, {:default, ""}, :string}
}
end
@spec defs_by_name() :: %{
required(atom) => {non_neg_integer, Protox.Types.kind(), Protox.Types.type()}
}
def(defs_by_name()) do
%{
id: {3, {:default, ""}, :string},
location: {1, {:default, nil}, {:message, CucumberMessages.Location}},
name: {2, {:default, ""}, :string}
}
end
@spec required_fields() :: []
def(required_fields()) do
[]
end
@spec unknown_fields(struct) :: [{non_neg_integer, Protox.Types.tag(), binary}]
def(unknown_fields(msg)) do
msg.__uf__()
end
@spec unknown_fields_name() :: :__uf__
def(unknown_fields_name()) do
:__uf__
end
@spec clear_unknown_fields(struct) :: struct
def(clear_unknown_fields(msg)) do
struct!(msg, [{unknown_fields_name(), []}])
end
@spec syntax() :: atom
def(syntax()) do
:proto3
end
[
@spec(
default(atom) :: {:ok, boolean | integer | String.t() | binary | float} | {:error, atom}
),
[
def(default(:location)) do
{:ok, nil}
end,
def(default(:name)) do
{:ok, ""}
end,
def(default(:id)) do
{:ok, ""}
end
],
def(default(_)) do
{:error, :no_such_field}
end
]
)
[]
end,
defmodule(CucumberMessages.PickleStepArgument.PickleDocString) do
@moduledoc false
(
defstruct(media_type: "", content: "", __uf__: [])
(
@spec encode(struct) :: {:ok, iodata} | {:error, any}
def(encode(msg)) do
try do
{:ok, encode!(msg)}
rescue
e ->
{:error, e}
end
end
@spec encode!(struct) :: iodata | no_return
def(encode!(msg)) do
[] |> encode_media_type(msg) |> encode_content(msg) |> encode_unknown_fields(msg)
end
[]
[
defp(encode_media_type(acc, msg)) do
field_value = msg.media_type()
if(field_value == "") do
acc
else
[acc, "\n", Protox.Encode.encode_string(field_value)]
end
end,
defp(encode_content(acc, msg)) do
field_value = msg.content()
if(field_value == "") do
acc
else
[acc, <<18>>, Protox.Encode.encode_string(field_value)]
end
end
]
defp(encode_unknown_fields(acc, msg)) do
Enum.reduce(msg.__struct__.unknown_fields(msg), acc, fn {tag, wire_type, bytes}, acc ->
case(wire_type) do
0 ->
[acc, Protox.Encode.make_key_bytes(tag, :int32), bytes]
1 ->
[acc, Protox.Encode.make_key_bytes(tag, :double), bytes]
2 ->
len_bytes = bytes |> byte_size() |> Protox.Varint.encode()
[acc, Protox.Encode.make_key_bytes(tag, :packed), len_bytes, bytes]
5 ->
[acc, Protox.Encode.make_key_bytes(tag, :float), bytes]
end
end)
end
)
(
@spec decode(binary) :: {:ok, struct} | {:error, any}
def(decode(bytes)) do
try do
{:ok, decode!(bytes)}
rescue
Protox.IllegalTagError ->
{:error, :illegal_tag}
e in Protox.RequiredFieldsError ->
{:error, {:missing_fields, e.missing_fields}}
e in Protox.DecodingError ->
{:error, {e.reason, e.binary}}
e ->
{:error, e}
end
end
(
@spec decode!(binary) :: struct | no_return
def(decode!(bytes)) do
parse_key_value(bytes, struct(CucumberMessages.PickleStepArgument.PickleDocString))
end
)
(
@spec parse_key_value(binary, struct) :: struct
defp(parse_key_value(<<>>, msg)) do
msg
end
defp(parse_key_value(bytes, msg)) do
{field, rest} =
case(Protox.Decode.parse_key(bytes)) do
{0, _, _} ->
raise(%Protox.IllegalTagError{})
{1, _, bytes} ->
{len, bytes} = Protox.Varint.decode(bytes)
<<delimited::binary-size(len), rest::binary>> = bytes
value = delimited
field = {:media_type, value}
{field, rest}
{2, _, bytes} ->
{len, bytes} = Protox.Varint.decode(bytes)
<<delimited::binary-size(len), rest::binary>> = bytes
value = delimited
field = {:content, value}
{field, rest}
{tag, wire_type, rest} ->
{value, new_rest} = Protox.Decode.parse_unknown(tag, wire_type, rest)
field =
{msg.__struct__.unknown_fields_name,
[value | msg.__struct__.unknown_fields(msg)]}
{field, new_rest}
end
msg_updated = struct(msg, [field])
parse_key_value(rest, msg_updated)
end
)
[]
)
@spec defs() :: %{
required(non_neg_integer) => {atom, Protox.Types.kind(), Protox.Types.type()}
}
def(defs()) do
%{1 => {:media_type, {:default, ""}, :string}, 2 => {:content, {:default, ""}, :string}}
end
@spec defs_by_name() :: %{
required(atom) => {non_neg_integer, Protox.Types.kind(), Protox.Types.type()}
}
def(defs_by_name()) do
%{content: {2, {:default, ""}, :string}, media_type: {1, {:default, ""}, :string}}
end
@spec required_fields() :: []
def(required_fields()) do
[]
end
@spec unknown_fields(struct) :: [{non_neg_integer, Protox.Types.tag(), binary}]
def(unknown_fields(msg)) do
msg.__uf__()
end
@spec unknown_fields_name() :: :__uf__
def(unknown_fields_name()) do
:__uf__
end
@spec clear_unknown_fields(struct) :: struct
def(clear_unknown_fields(msg)) do
struct!(msg, [{unknown_fields_name(), []}])
end
@spec syntax() :: atom
def(syntax()) do
:proto3
end
[
@spec(
default(atom) :: {:ok, boolean | integer | String.t() | binary | float} | {:error, atom}
),
[
def(default(:media_type)) do
{:ok, ""}
end,
def(default(:content)) do
{:ok, ""}
end
],
def(default(_)) do
{:error, :no_such_field}
end
]
)
[]
end,
defmodule(CucumberMessages.PickleStepArgument) do
@moduledoc false
(
defstruct(message: nil, __uf__: [])
(
@spec encode(struct) :: {:ok, iodata} | {:error, any}
def(encode(msg)) do
try do
{:ok, encode!(msg)}
rescue
e ->
{:error, e}
end
end
@spec encode!(struct) :: iodata | no_return
def(encode!(msg)) do
[] |> encode_message(msg) |> encode_unknown_fields(msg)
end
[
defp(encode_message(acc, msg)) do
case(msg.message()) do
nil ->
acc
{:doc_string, _field_value} ->
encode_doc_string(acc, msg)
{:data_table, _field_value} ->
encode_data_table(acc, msg)
end
end
]
[
defp(encode_doc_string(acc, msg)) do
{_, field_value} = msg.message()
[acc, "\n", Protox.Encode.encode_message(field_value)]
end,
defp(encode_data_table(acc, msg)) do
{_, field_value} = msg.message()
[acc, <<18>>, Protox.Encode.encode_message(field_value)]
end
]
defp(encode_unknown_fields(acc, msg)) do
Enum.reduce(msg.__struct__.unknown_fields(msg), acc, fn {tag, wire_type, bytes}, acc ->
case(wire_type) do
0 ->
[acc, Protox.Encode.make_key_bytes(tag, :int32), bytes]
1 ->
[acc, Protox.Encode.make_key_bytes(tag, :double), bytes]
2 ->
len_bytes = bytes |> byte_size() |> Protox.Varint.encode()
[acc, Protox.Encode.make_key_bytes(tag, :packed), len_bytes, bytes]
5 ->
[acc, Protox.Encode.make_key_bytes(tag, :float), bytes]
end
end)
end
)
(
@spec decode(binary) :: {:ok, struct} | {:error, any}
def(decode(bytes)) do
try do
{:ok, decode!(bytes)}
rescue
Protox.IllegalTagError ->
{:error, :illegal_tag}
e in Protox.RequiredFieldsError ->
{:error, {:missing_fields, e.missing_fields}}
e in Protox.DecodingError ->
{:error, {e.reason, e.binary}}
e ->
{:error, e}
end
end
(
@spec decode!(binary) :: struct | no_return
def(decode!(bytes)) do
parse_key_value(bytes, struct(CucumberMessages.PickleStepArgument))
end
)
(
@spec parse_key_value(binary, struct) :: struct
defp(parse_key_value(<<>>, msg)) do
msg
end
defp(parse_key_value(bytes, msg)) do
{field, rest} =
case(Protox.Decode.parse_key(bytes)) do
{0, _, _} ->
raise(%Protox.IllegalTagError{})
{1, _, bytes} ->
{len, bytes} = Protox.Varint.decode(bytes)
<<delimited::binary-size(len), rest::binary>> = bytes
value = CucumberMessages.PickleStepArgument.PickleDocString.decode!(delimited)
field =
case(msg.message()) do
{:doc_string, previous_value} ->
{:message, {:doc_string, Protox.Message.merge(previous_value, value)}}
_ ->
{:message, {:doc_string, value}}
end
{field, rest}
{2, _, bytes} ->
{len, bytes} = Protox.Varint.decode(bytes)
<<delimited::binary-size(len), rest::binary>> = bytes
value = CucumberMessages.PickleStepArgument.PickleTable.decode!(delimited)
field =
case(msg.message()) do
{:data_table, previous_value} ->
{:message, {:data_table, Protox.Message.merge(previous_value, value)}}
_ ->
{:message, {:data_table, value}}
end
{field, rest}
{tag, wire_type, rest} ->
{value, new_rest} = Protox.Decode.parse_unknown(tag, wire_type, rest)
field =
{msg.__struct__.unknown_fields_name,
[value | msg.__struct__.unknown_fields(msg)]}
{field, new_rest}
end
msg_updated = struct(msg, [field])
parse_key_value(rest, msg_updated)
end
)
[]
)
@spec defs() :: %{
required(non_neg_integer) => {atom, Protox.Types.kind(), Protox.Types.type()}
}
def(defs()) do
%{
1 =>
{:doc_string, {:oneof, :message},
{:message, CucumberMessages.PickleStepArgument.PickleDocString}},
2 =>
{:data_table, {:oneof, :message},
{:message, CucumberMessages.PickleStepArgument.PickleTable}}
}
end
@spec defs_by_name() :: %{
required(atom) => {non_neg_integer, Protox.Types.kind(), Protox.Types.type()}
}
def(defs_by_name()) do
%{
data_table:
{2, {:oneof, :message}, {:message, CucumberMessages.PickleStepArgument.PickleTable}},
doc_string:
{1, {:oneof, :message},
{:message, CucumberMessages.PickleStepArgument.PickleDocString}}
}
end
@spec required_fields() :: []
def(required_fields()) do
[]
end
@spec unknown_fields(struct) :: [{non_neg_integer, Protox.Types.tag(), binary}]
def(unknown_fields(msg)) do
msg.__uf__()
end
@spec unknown_fields_name() :: :__uf__
def(unknown_fields_name()) do
:__uf__
end
@spec clear_unknown_fields(struct) :: struct
def(clear_unknown_fields(msg)) do
struct!(msg, [{unknown_fields_name(), []}])
end
@spec syntax() :: atom
def(syntax()) do
:proto3
end
[
@spec(
default(atom) :: {:ok, boolean | integer | String.t() | binary | float} | {:error, atom}
),
[
def(default(:doc_string)) do
{:error, :no_default_value}
end,
def(default(:data_table)) do
{:error, :no_default_value}
end
],
def(default(_)) do
{:error, :no_such_field}
end
]
)
[]
end,
defmodule(CucumberMessages.ParseError) do
@moduledoc false
(
defstruct(source: nil, message: "", __uf__: [])
(
@spec encode(struct) :: {:ok, iodata} | {:error, any}
def(encode(msg)) do
try do
{:ok, encode!(msg)}
rescue
e ->
{:error, e}
end
end
@spec encode!(struct) :: iodata | no_return
def(encode!(msg)) do
[] |> encode_source(msg) |> encode_message(msg) |> encode_unknown_fields(msg)
end
[]
[
defp(encode_source(acc, msg)) do
field_value = msg.source()
if(field_value == nil) do
acc
else
[acc, "\n", Protox.Encode.encode_message(field_value)]
end
end,
defp(encode_message(acc, msg)) do
field_value = msg.message()
if(field_value == "") do
acc
else
[acc, <<18>>, Protox.Encode.encode_string(field_value)]
end
end
]
defp(encode_unknown_fields(acc, msg)) do
Enum.reduce(msg.__struct__.unknown_fields(msg), acc, fn {tag, wire_type, bytes}, acc ->
case(wire_type) do
0 ->
[acc, Protox.Encode.make_key_bytes(tag, :int32), bytes]
1 ->
[acc, Protox.Encode.make_key_bytes(tag, :double), bytes]
2 ->
len_bytes = bytes |> byte_size() |> Protox.Varint.encode()
[acc, Protox.Encode.make_key_bytes(tag, :packed), len_bytes, bytes]
5 ->
[acc, Protox.Encode.make_key_bytes(tag, :float), bytes]
end
end)
end
)
(
@spec decode(binary) :: {:ok, struct} | {:error, any}
def(decode(bytes)) do
try do
{:ok, decode!(bytes)}
rescue
Protox.IllegalTagError ->
{:error, :illegal_tag}
e in Protox.RequiredFieldsError ->
{:error, {:missing_fields, e.missing_fields}}
e in Protox.DecodingError ->
{:error, {e.reason, e.binary}}
e ->
{:error, e}
end
end
(
@spec decode!(binary) :: struct | no_return
def(decode!(bytes)) do
parse_key_value(bytes, struct(CucumberMessages.ParseError))
end
)
(
@spec parse_key_value(binary, struct) :: struct
defp(parse_key_value(<<>>, msg)) do
msg
end
defp(parse_key_value(bytes, msg)) do
{field, rest} =
case(Protox.Decode.parse_key(bytes)) do
{0, _, _} ->
raise(%Protox.IllegalTagError{})
{1, _, bytes} ->
{len, bytes} = Protox.Varint.decode(bytes)
<<delimited::binary-size(len), rest::binary>> = bytes
value = CucumberMessages.SourceReference.decode!(delimited)
field = {:source, Protox.Message.merge(msg.source(), value)}
{field, rest}
{2, _, bytes} ->
{len, bytes} = Protox.Varint.decode(bytes)
<<delimited::binary-size(len), rest::binary>> = bytes
value = delimited
field = {:message, value}
{field, rest}
{tag, wire_type, rest} ->
{value, new_rest} = Protox.Decode.parse_unknown(tag, wire_type, rest)
field =
{msg.__struct__.unknown_fields_name,
[value | msg.__struct__.unknown_fields(msg)]}
{field, new_rest}
end
msg_updated = struct(msg, [field])
parse_key_value(rest, msg_updated)
end
)
[]
)
@spec defs() :: %{
required(non_neg_integer) => {atom, Protox.Types.kind(), Protox.Types.type()}
}
def(defs()) do
%{
1 => {:source, {:default, nil}, {:message, CucumberMessages.SourceReference}},
2 => {:message, {:default, ""}, :string}
}
end
@spec defs_by_name() :: %{
required(atom) => {non_neg_integer, Protox.Types.kind(), Protox.Types.type()}
}
def(defs_by_name()) do
%{
message: {2, {:default, ""}, :string},
source: {1, {:default, nil}, {:message, CucumberMessages.SourceReference}}
}
end
@spec required_fields() :: []
def(required_fields()) do
[]
end
@spec unknown_fields(struct) :: [{non_neg_integer, Protox.Types.tag(), binary}]
def(unknown_fields(msg)) do
msg.__uf__()
end
@spec unknown_fields_name() :: :__uf__
def(unknown_fields_name()) do
:__uf__
end
@spec clear_unknown_fields(struct) :: struct
def(clear_unknown_fields(msg)) do
struct!(msg, [{unknown_fields_name(), []}])
end
@spec syntax() :: atom
def(syntax()) do
:proto3
end
[
@spec(
default(atom) :: {:ok, boolean | integer | String.t() | binary | float} | {:error, atom}
),
[
def(default(:source)) do
{:ok, nil}
end,
def(default(:message)) do
{:ok, ""}
end
],
def(default(_)) do
{:error, :no_such_field}
end
]
)
[]
end,
defmodule(CucumberMessages.PickleStepArgument.PickleTable) do
@moduledoc false
(
defstruct(rows: [], __uf__: [])
(
@spec encode(struct) :: {:ok, iodata} | {:error, any}
def(encode(msg)) do
try do
{:ok, encode!(msg)}
rescue
e ->
{:error, e}
end
end
@spec encode!(struct) :: iodata | no_return
def(encode!(msg)) do
[] |> encode_rows(msg) |> encode_unknown_fields(msg)
end
[]
[
defp(encode_rows(acc, msg)) do
case(msg.rows()) do
[] ->
acc
values ->
[
acc,
Enum.reduce(values, [], fn value, acc ->
[acc, "\n", Protox.Encode.encode_message(value)]
end)
]
end
end
]
defp(encode_unknown_fields(acc, msg)) do
Enum.reduce(msg.__struct__.unknown_fields(msg), acc, fn {tag, wire_type, bytes}, acc ->
case(wire_type) do
0 ->
[acc, Protox.Encode.make_key_bytes(tag, :int32), bytes]
1 ->
[acc, Protox.Encode.make_key_bytes(tag, :double), bytes]
2 ->
len_bytes = bytes |> byte_size() |> Protox.Varint.encode()
[acc, Protox.Encode.make_key_bytes(tag, :packed), len_bytes, bytes]
5 ->
[acc, Protox.Encode.make_key_bytes(tag, :float), bytes]
end
end)
end
)
(
@spec decode(binary) :: {:ok, struct} | {:error, any}
def(decode(bytes)) do
try do
{:ok, decode!(bytes)}
rescue
Protox.IllegalTagError ->
{:error, :illegal_tag}
e in Protox.RequiredFieldsError ->
{:error, {:missing_fields, e.missing_fields}}
e in Protox.DecodingError ->
{:error, {e.reason, e.binary}}
e ->
{:error, e}
end
end
(
@spec decode!(binary) :: struct | no_return
def(decode!(bytes)) do
parse_key_value(bytes, struct(CucumberMessages.PickleStepArgument.PickleTable))
end
)
(
@spec parse_key_value(binary, struct) :: struct
defp(parse_key_value(<<>>, msg)) do
msg
end
defp(parse_key_value(bytes, msg)) do
{field, rest} =
case(Protox.Decode.parse_key(bytes)) do
{0, _, _} ->
raise(%Protox.IllegalTagError{})
{1, _, bytes} ->
{len, bytes} = Protox.Varint.decode(bytes)
<<delimited::binary-size(len), rest::binary>> = bytes
value =
CucumberMessages.PickleStepArgument.PickleTable.PickleTableRow.decode!(
delimited
)
field = {:rows, msg.rows() ++ List.wrap(value)}
{field, rest}
{tag, wire_type, rest} ->
{value, new_rest} = Protox.Decode.parse_unknown(tag, wire_type, rest)
field =
{msg.__struct__.unknown_fields_name,
[value | msg.__struct__.unknown_fields(msg)]}
{field, new_rest}
end
msg_updated = struct(msg, [field])
parse_key_value(rest, msg_updated)
end
)
[]
)
@spec defs() :: %{
required(non_neg_integer) => {atom, Protox.Types.kind(), Protox.Types.type()}
}
def(defs()) do
%{
1 =>
{:rows, :unpacked,
{:message, CucumberMessages.PickleStepArgument.PickleTable.PickleTableRow}}
}
end
@spec defs_by_name() :: %{
required(atom) => {non_neg_integer, Protox.Types.kind(), Protox.Types.type()}
}
def(defs_by_name()) do
%{
rows:
{1, :unpacked,
{:message, CucumberMessages.PickleStepArgument.PickleTable.PickleTableRow}}
}
end
@spec required_fields() :: []
def(required_fields()) do
[]
end
@spec unknown_fields(struct) :: [{non_neg_integer, Protox.Types.tag(), binary}]
def(unknown_fields(msg)) do
msg.__uf__()
end
@spec unknown_fields_name() :: :__uf__
def(unknown_fields_name()) do
:__uf__
end
@spec clear_unknown_fields(struct) :: struct
def(clear_unknown_fields(msg)) do
struct!(msg, [{unknown_fields_name(), []}])
end
@spec syntax() :: atom
def(syntax()) do
:proto3
end
[
@spec(
default(atom) :: {:ok, boolean | integer | String.t() | binary | float} | {:error, atom}
),
[
def(default(:rows)) do
{:error, :no_default_value}
end
],
def(default(_)) do
{:error, :no_such_field}
end
]
)
[]
end,
defmodule(CucumberMessages.GherkinDocument.Feature.Background) do
@moduledoc false
(
defstruct(
location: nil,
keyword: "",
name: "",
description: "",
steps: [],
id: "",
__uf__: []
)
(
@spec encode(struct) :: {:ok, iodata} | {:error, any}
def(encode(msg)) do
try do
{:ok, encode!(msg)}
rescue
e ->
{:error, e}
end
end
@spec encode!(struct) :: iodata | no_return
def(encode!(msg)) do
[]
|> encode_location(msg)
|> encode_keyword(msg)
|> encode_name(msg)
|> encode_description(msg)
|> encode_steps(msg)
|> encode_id(msg)
|> encode_unknown_fields(msg)
end
[]
[
defp(encode_location(acc, msg)) do
field_value = msg.location()
if(field_value == nil) do
acc
else
[acc, "\n", Protox.Encode.encode_message(field_value)]
end
end,
defp(encode_keyword(acc, msg)) do
field_value = msg.keyword()
if(field_value == "") do
acc
else
[acc, <<18>>, Protox.Encode.encode_string(field_value)]
end
end,
defp(encode_name(acc, msg)) do
field_value = msg.name()
if(field_value == "") do
acc
else
[acc, <<26>>, Protox.Encode.encode_string(field_value)]
end
end,
defp(encode_description(acc, msg)) do
field_value = msg.description()
if(field_value == "") do
acc
else
[acc, "\"", Protox.Encode.encode_string(field_value)]
end
end,
defp(encode_steps(acc, msg)) do
case(msg.steps()) do
[] ->
acc
values ->
[
acc,
Enum.reduce(values, [], fn value, acc ->
[acc, "*", Protox.Encode.encode_message(value)]
end)
]
end
end,
defp(encode_id(acc, msg)) do
field_value = msg.id()
if(field_value == "") do
acc
else
[acc, "2", Protox.Encode.encode_string(field_value)]
end
end
]
defp(encode_unknown_fields(acc, msg)) do
Enum.reduce(msg.__struct__.unknown_fields(msg), acc, fn {tag, wire_type, bytes}, acc ->
case(wire_type) do
0 ->
[acc, Protox.Encode.make_key_bytes(tag, :int32), bytes]
1 ->
[acc, Protox.Encode.make_key_bytes(tag, :double), bytes]
2 ->
len_bytes = bytes |> byte_size() |> Protox.Varint.encode()
[acc, Protox.Encode.make_key_bytes(tag, :packed), len_bytes, bytes]
5 ->
[acc, Protox.Encode.make_key_bytes(tag, :float), bytes]
end
end)
end
)
(
@spec decode(binary) :: {:ok, struct} | {:error, any}
def(decode(bytes)) do
try do
{:ok, decode!(bytes)}
rescue
Protox.IllegalTagError ->
{:error, :illegal_tag}
e in Protox.RequiredFieldsError ->
{:error, {:missing_fields, e.missing_fields}}
e in Protox.DecodingError ->
{:error, {e.reason, e.binary}}
e ->
{:error, e}
end
end
(
@spec decode!(binary) :: struct | no_return
def(decode!(bytes)) do
parse_key_value(bytes, struct(CucumberMessages.GherkinDocument.Feature.Background))
end
)
(
@spec parse_key_value(binary, struct) :: struct
defp(parse_key_value(<<>>, msg)) do
msg
end
defp(parse_key_value(bytes, msg)) do
{field, rest} =
case(Protox.Decode.parse_key(bytes)) do
{0, _, _} ->
raise(%Protox.IllegalTagError{})
{1, _, bytes} ->
{len, bytes} = Protox.Varint.decode(bytes)
<<delimited::binary-size(len), rest::binary>> = bytes
value = CucumberMessages.Location.decode!(delimited)
field = {:location, Protox.Message.merge(msg.location(), value)}
{field, rest}
{2, _, bytes} ->
{len, bytes} = Protox.Varint.decode(bytes)
<<delimited::binary-size(len), rest::binary>> = bytes
value = delimited
field = {:keyword, value}
{field, rest}
{3, _, bytes} ->
{len, bytes} = Protox.Varint.decode(bytes)
<<delimited::binary-size(len), rest::binary>> = bytes
value = delimited
field = {:name, value}
{field, rest}
{4, _, bytes} ->
{len, bytes} = Protox.Varint.decode(bytes)
<<delimited::binary-size(len), rest::binary>> = bytes
value = delimited
field = {:description, value}
{field, rest}
{5, _, bytes} ->
{len, bytes} = Protox.Varint.decode(bytes)
<<delimited::binary-size(len), rest::binary>> = bytes
value = CucumberMessages.GherkinDocument.Feature.Step.decode!(delimited)
field = {:steps, msg.steps() ++ List.wrap(value)}
{field, rest}
{6, _, bytes} ->
{len, bytes} = Protox.Varint.decode(bytes)
<<delimited::binary-size(len), rest::binary>> = bytes
value = delimited
field = {:id, value}
{field, rest}
{tag, wire_type, rest} ->
{value, new_rest} = Protox.Decode.parse_unknown(tag, wire_type, rest)
field =
{msg.__struct__.unknown_fields_name,
[value | msg.__struct__.unknown_fields(msg)]}
{field, new_rest}
end
msg_updated = struct(msg, [field])
parse_key_value(rest, msg_updated)
end
)
[]
)
@spec defs() :: %{
required(non_neg_integer) => {atom, Protox.Types.kind(), Protox.Types.type()}
}
def(defs()) do
%{
1 => {:location, {:default, nil}, {:message, CucumberMessages.Location}},
2 => {:keyword, {:default, ""}, :string},
3 => {:name, {:default, ""}, :string},
4 => {:description, {:default, ""}, :string},
5 => {:steps, :unpacked, {:message, CucumberMessages.GherkinDocument.Feature.Step}},
6 => {:id, {:default, ""}, :string}
}
end
@spec defs_by_name() :: %{
required(atom) => {non_neg_integer, Protox.Types.kind(), Protox.Types.type()}
}
def(defs_by_name()) do
%{
description: {4, {:default, ""}, :string},
id: {6, {:default, ""}, :string},
keyword: {2, {:default, ""}, :string},
location: {1, {:default, nil}, {:message, CucumberMessages.Location}},
name: {3, {:default, ""}, :string},
steps: {5, :unpacked, {:message, CucumberMessages.GherkinDocument.Feature.Step}}
}
end
@spec required_fields() :: []
def(required_fields()) do
[]
end
@spec unknown_fields(struct) :: [{non_neg_integer, Protox.Types.tag(), binary}]
def(unknown_fields(msg)) do
msg.__uf__()
end
@spec unknown_fields_name() :: :__uf__
def(unknown_fields_name()) do
:__uf__
end
@spec clear_unknown_fields(struct) :: struct
def(clear_unknown_fields(msg)) do
struct!(msg, [{unknown_fields_name(), []}])
end
@spec syntax() :: atom
def(syntax()) do
:proto3
end
[
@spec(
default(atom) :: {:ok, boolean | integer | String.t() | binary | float} | {:error, atom}
),
[
def(default(:location)) do
{:ok, nil}
end,
def(default(:keyword)) do
{:ok, ""}
end,
def(default(:name)) do
{:ok, ""}
end,
def(default(:description)) do
{:ok, ""}
end,
def(default(:steps)) do
{:error, :no_default_value}
end,
def(default(:id)) do
{:ok, ""}
end
],
def(default(_)) do
{:error, :no_such_field}
end
]
)
[]
end,
defmodule(CucumberMessages.TestStepStarted) do
@moduledoc false
(
defstruct(timestamp: nil, test_step_id: "", test_case_started_id: "", __uf__: [])
(
@spec encode(struct) :: {:ok, iodata} | {:error, any}
def(encode(msg)) do
try do
{:ok, encode!(msg)}
rescue
e ->
{:error, e}
end
end
@spec encode!(struct) :: iodata | no_return
def(encode!(msg)) do
[]
|> encode_timestamp(msg)
|> encode_test_step_id(msg)
|> encode_test_case_started_id(msg)
|> encode_unknown_fields(msg)
end
[]
[
defp(encode_timestamp(acc, msg)) do
field_value = msg.timestamp()
if(field_value == nil) do
acc
else
[acc, "\n", Protox.Encode.encode_message(field_value)]
end
end,
defp(encode_test_step_id(acc, msg)) do
field_value = msg.test_step_id()
if(field_value == "") do
acc
else
[acc, <<18>>, Protox.Encode.encode_string(field_value)]
end
end,
defp(encode_test_case_started_id(acc, msg)) do
field_value = msg.test_case_started_id()
if(field_value == "") do
acc
else
[acc, <<26>>, Protox.Encode.encode_string(field_value)]
end
end
]
defp(encode_unknown_fields(acc, msg)) do
Enum.reduce(msg.__struct__.unknown_fields(msg), acc, fn {tag, wire_type, bytes}, acc ->
case(wire_type) do
0 ->
[acc, Protox.Encode.make_key_bytes(tag, :int32), bytes]
1 ->
[acc, Protox.Encode.make_key_bytes(tag, :double), bytes]
2 ->
len_bytes = bytes |> byte_size() |> Protox.Varint.encode()
[acc, Protox.Encode.make_key_bytes(tag, :packed), len_bytes, bytes]
5 ->
[acc, Protox.Encode.make_key_bytes(tag, :float), bytes]
end
end)
end
)
(
@spec decode(binary) :: {:ok, struct} | {:error, any}
def(decode(bytes)) do
try do
{:ok, decode!(bytes)}
rescue
Protox.IllegalTagError ->
{:error, :illegal_tag}
e in Protox.RequiredFieldsError ->
{:error, {:missing_fields, e.missing_fields}}
e in Protox.DecodingError ->
{:error, {e.reason, e.binary}}
e ->
{:error, e}
end
end
(
@spec decode!(binary) :: struct | no_return
def(decode!(bytes)) do
parse_key_value(bytes, struct(CucumberMessages.TestStepStarted))
end
)
(
@spec parse_key_value(binary, struct) :: struct
defp(parse_key_value(<<>>, msg)) do
msg
end
defp(parse_key_value(bytes, msg)) do
{field, rest} =
case(Protox.Decode.parse_key(bytes)) do
{0, _, _} ->
raise(%Protox.IllegalTagError{})
{1, _, bytes} ->
{len, bytes} = Protox.Varint.decode(bytes)
<<delimited::binary-size(len), rest::binary>> = bytes
value = CucumberMessages.Timestamp.decode!(delimited)
field = {:timestamp, Protox.Message.merge(msg.timestamp(), value)}
{field, rest}
{2, _, bytes} ->
{len, bytes} = Protox.Varint.decode(bytes)
<<delimited::binary-size(len), rest::binary>> = bytes
value = delimited
field = {:test_step_id, value}
{field, rest}
{3, _, bytes} ->
{len, bytes} = Protox.Varint.decode(bytes)
<<delimited::binary-size(len), rest::binary>> = bytes
value = delimited
field = {:test_case_started_id, value}
{field, rest}
{tag, wire_type, rest} ->
{value, new_rest} = Protox.Decode.parse_unknown(tag, wire_type, rest)
field =
{msg.__struct__.unknown_fields_name,
[value | msg.__struct__.unknown_fields(msg)]}
{field, new_rest}
end
msg_updated = struct(msg, [field])
parse_key_value(rest, msg_updated)
end
)
[]
)
@spec defs() :: %{
required(non_neg_integer) => {atom, Protox.Types.kind(), Protox.Types.type()}
}
def(defs()) do
%{
1 => {:timestamp, {:default, nil}, {:message, CucumberMessages.Timestamp}},
2 => {:test_step_id, {:default, ""}, :string},
3 => {:test_case_started_id, {:default, ""}, :string}
}
end
@spec defs_by_name() :: %{
required(atom) => {non_neg_integer, Protox.Types.kind(), Protox.Types.type()}
}
def(defs_by_name()) do
%{
test_case_started_id: {3, {:default, ""}, :string},
test_step_id: {2, {:default, ""}, :string},
timestamp: {1, {:default, nil}, {:message, CucumberMessages.Timestamp}}
}
end
@spec required_fields() :: []
def(required_fields()) do
[]
end
@spec unknown_fields(struct) :: [{non_neg_integer, Protox.Types.tag(), binary}]
def(unknown_fields(msg)) do
msg.__uf__()
end
@spec unknown_fields_name() :: :__uf__
def(unknown_fields_name()) do
:__uf__
end
@spec clear_unknown_fields(struct) :: struct
def(clear_unknown_fields(msg)) do
struct!(msg, [{unknown_fields_name(), []}])
end
@spec syntax() :: atom
def(syntax()) do
:proto3
end
[
@spec(
default(atom) :: {:ok, boolean | integer | String.t() | binary | float} | {:error, atom}
),
[
def(default(:timestamp)) do
{:ok, nil}
end,
def(default(:test_step_id)) do
{:ok, ""}
end,
def(default(:test_case_started_id)) do
{:ok, ""}
end
],
def(default(_)) do
{:error, :no_such_field}
end
]
)
[]
end,
defmodule(CucumberMessages.Attachment) do
@moduledoc false
(
defstruct(
source: nil,
test_step_id: "",
test_case_started_id: "",
body: "",
media_type: "",
content_encoding: :IDENTITY,
__uf__: []
)
(
@spec encode(struct) :: {:ok, iodata} | {:error, any}
def(encode(msg)) do
try do
{:ok, encode!(msg)}
rescue
e ->
{:error, e}
end
end
@spec encode!(struct) :: iodata | no_return
def(encode!(msg)) do
[]
|> encode_source(msg)
|> encode_test_step_id(msg)
|> encode_test_case_started_id(msg)
|> encode_body(msg)
|> encode_media_type(msg)
|> encode_content_encoding(msg)
|> encode_unknown_fields(msg)
end
[]
[
defp(encode_source(acc, msg)) do
field_value = msg.source()
if(field_value == nil) do
acc
else
[acc, "\n", Protox.Encode.encode_message(field_value)]
end
end,
defp(encode_test_step_id(acc, msg)) do
field_value = msg.test_step_id()
if(field_value == "") do
acc
else
[acc, <<18>>, Protox.Encode.encode_string(field_value)]
end
end,
defp(encode_test_case_started_id(acc, msg)) do
field_value = msg.test_case_started_id()
if(field_value == "") do
acc
else
[acc, <<26>>, Protox.Encode.encode_string(field_value)]
end
end,
defp(encode_body(acc, msg)) do
field_value = msg.body()
if(field_value == "") do
acc
else
[acc, "\"", Protox.Encode.encode_string(field_value)]
end
end,
defp(encode_media_type(acc, msg)) do
field_value = msg.media_type()
if(field_value == "") do
acc
else
[acc, "*", Protox.Encode.encode_string(field_value)]
end
end,
defp(encode_content_encoding(acc, msg)) do
field_value = msg.content_encoding()
if(field_value == :IDENTITY) do
acc
else
[
acc,
"0",
field_value
|> CucumberMessages.Attachment.ContentEncoding.encode()
|> Protox.Encode.encode_enum()
]
end
end
]
defp(encode_unknown_fields(acc, msg)) do
Enum.reduce(msg.__struct__.unknown_fields(msg), acc, fn {tag, wire_type, bytes}, acc ->
case(wire_type) do
0 ->
[acc, Protox.Encode.make_key_bytes(tag, :int32), bytes]
1 ->
[acc, Protox.Encode.make_key_bytes(tag, :double), bytes]
2 ->
len_bytes = bytes |> byte_size() |> Protox.Varint.encode()
[acc, Protox.Encode.make_key_bytes(tag, :packed), len_bytes, bytes]
5 ->
[acc, Protox.Encode.make_key_bytes(tag, :float), bytes]
end
end)
end
)
(
@spec decode(binary) :: {:ok, struct} | {:error, any}
def(decode(bytes)) do
try do
{:ok, decode!(bytes)}
rescue
Protox.IllegalTagError ->
{:error, :illegal_tag}
e in Protox.RequiredFieldsError ->
{:error, {:missing_fields, e.missing_fields}}
e in Protox.DecodingError ->
{:error, {e.reason, e.binary}}
e ->
{:error, e}
end
end
(
@spec decode!(binary) :: struct | no_return
def(decode!(bytes)) do
parse_key_value(bytes, struct(CucumberMessages.Attachment))
end
)
(
@spec parse_key_value(binary, struct) :: struct
defp(parse_key_value(<<>>, msg)) do
msg
end
defp(parse_key_value(bytes, msg)) do
{field, rest} =
case(Protox.Decode.parse_key(bytes)) do
{0, _, _} ->
raise(%Protox.IllegalTagError{})
{1, _, bytes} ->
{len, bytes} = Protox.Varint.decode(bytes)
<<delimited::binary-size(len), rest::binary>> = bytes
value = CucumberMessages.SourceReference.decode!(delimited)
field = {:source, Protox.Message.merge(msg.source(), value)}
{field, rest}
{2, _, bytes} ->
{len, bytes} = Protox.Varint.decode(bytes)
<<delimited::binary-size(len), rest::binary>> = bytes
value = delimited
field = {:test_step_id, value}
{field, rest}
{3, _, bytes} ->
{len, bytes} = Protox.Varint.decode(bytes)
<<delimited::binary-size(len), rest::binary>> = bytes
value = delimited
field = {:test_case_started_id, value}
{field, rest}
{4, _, bytes} ->
{len, bytes} = Protox.Varint.decode(bytes)
<<delimited::binary-size(len), rest::binary>> = bytes
value = delimited
field = {:body, value}
{field, rest}
{5, _, bytes} ->
{len, bytes} = Protox.Varint.decode(bytes)
<<delimited::binary-size(len), rest::binary>> = bytes
value = delimited
field = {:media_type, value}
{field, rest}
{6, _, bytes} ->
{value, rest} =
Protox.Decode.parse_enum(bytes, CucumberMessages.Attachment.ContentEncoding)
field = {:content_encoding, value}
{field, rest}
{tag, wire_type, rest} ->
{value, new_rest} = Protox.Decode.parse_unknown(tag, wire_type, rest)
field =
{msg.__struct__.unknown_fields_name,
[value | msg.__struct__.unknown_fields(msg)]}
{field, new_rest}
end
msg_updated = struct(msg, [field])
parse_key_value(rest, msg_updated)
end
)
[]
)
@spec defs() :: %{
required(non_neg_integer) => {atom, Protox.Types.kind(), Protox.Types.type()}
}
def(defs()) do
%{
1 => {:source, {:default, nil}, {:message, CucumberMessages.SourceReference}},
2 => {:test_step_id, {:default, ""}, :string},
3 => {:test_case_started_id, {:default, ""}, :string},
4 => {:body, {:default, ""}, :string},
5 => {:media_type, {:default, ""}, :string},
6 =>
{:content_encoding, {:default, :IDENTITY},
{:enum, CucumberMessages.Attachment.ContentEncoding}}
}
end
@spec defs_by_name() :: %{
required(atom) => {non_neg_integer, Protox.Types.kind(), Protox.Types.type()}
}
def(defs_by_name()) do
%{
body: {4, {:default, ""}, :string},
content_encoding:
{6, {:default, :IDENTITY}, {:enum, CucumberMessages.Attachment.ContentEncoding}},
media_type: {5, {:default, ""}, :string},
source: {1, {:default, nil}, {:message, CucumberMessages.SourceReference}},
test_case_started_id: {3, {:default, ""}, :string},
test_step_id: {2, {:default, ""}, :string}
}
end
@spec required_fields() :: []
def(required_fields()) do
[]
end
@spec unknown_fields(struct) :: [{non_neg_integer, Protox.Types.tag(), binary}]
def(unknown_fields(msg)) do
msg.__uf__()
end
@spec unknown_fields_name() :: :__uf__
def(unknown_fields_name()) do
:__uf__
end
@spec clear_unknown_fields(struct) :: struct
def(clear_unknown_fields(msg)) do
struct!(msg, [{unknown_fields_name(), []}])
end
@spec syntax() :: atom
def(syntax()) do
:proto3
end
[
@spec(
default(atom) :: {:ok, boolean | integer | String.t() | binary | float} | {:error, atom}
),
[
def(default(:source)) do
{:ok, nil}
end,
def(default(:test_step_id)) do
{:ok, ""}
end,
def(default(:test_case_started_id)) do
{:ok, ""}
end,
def(default(:body)) do
{:ok, ""}
end,
def(default(:media_type)) do
{:ok, ""}
end,
def(default(:content_encoding)) do
{:ok, :IDENTITY}
end
],
def(default(_)) do
{:error, :no_such_field}
end
]
)
[]
end,
defmodule(CucumberMessages.ParameterType) do
@moduledoc false
(
defstruct(
name: "",
regular_expressions: [],
prefer_for_regular_expression_match: false,
use_for_snippets: false,
id: "",
__uf__: []
)
(
@spec encode(struct) :: {:ok, iodata} | {:error, any}
def(encode(msg)) do
try do
{:ok, encode!(msg)}
rescue
e ->
{:error, e}
end
end
@spec encode!(struct) :: iodata | no_return
def(encode!(msg)) do
[]
|> encode_name(msg)
|> encode_regular_expressions(msg)
|> encode_prefer_for_regular_expression_match(msg)
|> encode_use_for_snippets(msg)
|> encode_id(msg)
|> encode_unknown_fields(msg)
end
[]
[
defp(encode_name(acc, msg)) do
field_value = msg.name()
if(field_value == "") do
acc
else
[acc, "\n", Protox.Encode.encode_string(field_value)]
end
end,
defp(encode_regular_expressions(acc, msg)) do
case(msg.regular_expressions()) do
[] ->
acc
values ->
[
acc,
Enum.reduce(values, [], fn value, acc ->
[acc, <<18>>, Protox.Encode.encode_string(value)]
end)
]
end
end,
defp(encode_prefer_for_regular_expression_match(acc, msg)) do
field_value = msg.prefer_for_regular_expression_match()
if(field_value == false) do
acc
else
[acc, <<24>>, Protox.Encode.encode_bool(field_value)]
end
end,
defp(encode_use_for_snippets(acc, msg)) do
field_value = msg.use_for_snippets()
if(field_value == false) do
acc
else
[acc, " ", Protox.Encode.encode_bool(field_value)]
end
end,
defp(encode_id(acc, msg)) do
field_value = msg.id()
if(field_value == "") do
acc
else
[acc, "*", Protox.Encode.encode_string(field_value)]
end
end
]
defp(encode_unknown_fields(acc, msg)) do
Enum.reduce(msg.__struct__.unknown_fields(msg), acc, fn {tag, wire_type, bytes}, acc ->
case(wire_type) do
0 ->
[acc, Protox.Encode.make_key_bytes(tag, :int32), bytes]
1 ->
[acc, Protox.Encode.make_key_bytes(tag, :double), bytes]
2 ->
len_bytes = bytes |> byte_size() |> Protox.Varint.encode()
[acc, Protox.Encode.make_key_bytes(tag, :packed), len_bytes, bytes]
5 ->
[acc, Protox.Encode.make_key_bytes(tag, :float), bytes]
end
end)
end
)
(
@spec decode(binary) :: {:ok, struct} | {:error, any}
def(decode(bytes)) do
try do
{:ok, decode!(bytes)}
rescue
Protox.IllegalTagError ->
{:error, :illegal_tag}
e in Protox.RequiredFieldsError ->
{:error, {:missing_fields, e.missing_fields}}
e in Protox.DecodingError ->
{:error, {e.reason, e.binary}}
e ->
{:error, e}
end
end
(
@spec decode!(binary) :: struct | no_return
def(decode!(bytes)) do
parse_key_value(bytes, struct(CucumberMessages.ParameterType))
end
)
(
@spec parse_key_value(binary, struct) :: struct
defp(parse_key_value(<<>>, msg)) do
msg
end
defp(parse_key_value(bytes, msg)) do
{field, rest} =
case(Protox.Decode.parse_key(bytes)) do
{0, _, _} ->
raise(%Protox.IllegalTagError{})
{1, _, bytes} ->
{len, bytes} = Protox.Varint.decode(bytes)
<<delimited::binary-size(len), rest::binary>> = bytes
value = delimited
field = {:name, value}
{field, rest}
{2, _, bytes} ->
{len, bytes} = Protox.Varint.decode(bytes)
<<delimited::binary-size(len), rest::binary>> = bytes
value = delimited
field = {:regular_expressions, msg.regular_expressions() ++ List.wrap(value)}
{field, rest}
{3, _, bytes} ->
{value, rest} = Protox.Decode.parse_bool(bytes)
field = {:prefer_for_regular_expression_match, value}
{field, rest}
{4, _, bytes} ->
{value, rest} = Protox.Decode.parse_bool(bytes)
field = {:use_for_snippets, value}
{field, rest}
{5, _, bytes} ->
{len, bytes} = Protox.Varint.decode(bytes)
<<delimited::binary-size(len), rest::binary>> = bytes
value = delimited
field = {:id, value}
{field, rest}
{tag, wire_type, rest} ->
{value, new_rest} = Protox.Decode.parse_unknown(tag, wire_type, rest)
field =
{msg.__struct__.unknown_fields_name,
[value | msg.__struct__.unknown_fields(msg)]}
{field, new_rest}
end
msg_updated = struct(msg, [field])
parse_key_value(rest, msg_updated)
end
)
[]
)
@spec defs() :: %{
required(non_neg_integer) => {atom, Protox.Types.kind(), Protox.Types.type()}
}
def(defs()) do
%{
1 => {:name, {:default, ""}, :string},
2 => {:regular_expressions, :unpacked, :string},
3 => {:prefer_for_regular_expression_match, {:default, false}, :bool},
4 => {:use_for_snippets, {:default, false}, :bool},
5 => {:id, {:default, ""}, :string}
}
end
@spec defs_by_name() :: %{
required(atom) => {non_neg_integer, Protox.Types.kind(), Protox.Types.type()}
}
def(defs_by_name()) do
%{
id: {5, {:default, ""}, :string},
name: {1, {:default, ""}, :string},
prefer_for_regular_expression_match: {3, {:default, false}, :bool},
regular_expressions: {2, :unpacked, :string},
use_for_snippets: {4, {:default, false}, :bool}
}
end
@spec required_fields() :: []
def(required_fields()) do
[]
end
@spec unknown_fields(struct) :: [{non_neg_integer, Protox.Types.tag(), binary}]
def(unknown_fields(msg)) do
msg.__uf__()
end
@spec unknown_fields_name() :: :__uf__
def(unknown_fields_name()) do
:__uf__
end
@spec clear_unknown_fields(struct) :: struct
def(clear_unknown_fields(msg)) do
struct!(msg, [{unknown_fields_name(), []}])
end
@spec syntax() :: atom
def(syntax()) do
:proto3
end
[
@spec(
default(atom) :: {:ok, boolean | integer | String.t() | binary | float} | {:error, atom}
),
[
def(default(:name)) do
{:ok, ""}
end,
def(default(:regular_expressions)) do
{:error, :no_default_value}
end,
def(default(:prefer_for_regular_expression_match)) do
{:ok, false}
end,
def(default(:use_for_snippets)) do
{:ok, false}
end,
def(default(:id)) do
{:ok, ""}
end
],
def(default(_)) do
{:error, :no_such_field}
end
]
)
[]
end,
defmodule(CucumberMessages.Pickle.PickleStep) do
@moduledoc false
(
defstruct(text: "", argument: nil, id: "", ast_node_ids: [], __uf__: [])
(
@spec encode(struct) :: {:ok, iodata} | {:error, any}
def(encode(msg)) do
try do
{:ok, encode!(msg)}
rescue
e ->
{:error, e}
end
end
@spec encode!(struct) :: iodata | no_return
def(encode!(msg)) do
[]
|> encode_text(msg)
|> encode_argument(msg)
|> encode_id(msg)
|> encode_ast_node_ids(msg)
|> encode_unknown_fields(msg)
end
[]
[
defp(encode_text(acc, msg)) do
field_value = msg.text()
if(field_value == "") do
acc
else
[acc, "\n", Protox.Encode.encode_string(field_value)]
end
end,
defp(encode_argument(acc, msg)) do
field_value = msg.argument()
if(field_value == nil) do
acc
else
[acc, <<18>>, Protox.Encode.encode_message(field_value)]
end
end,
defp(encode_id(acc, msg)) do
field_value = msg.id()
if(field_value == "") do
acc
else
[acc, <<26>>, Protox.Encode.encode_string(field_value)]
end
end,
defp(encode_ast_node_ids(acc, msg)) do
case(msg.ast_node_ids()) do
[] ->
acc
values ->
[
acc,
Enum.reduce(values, [], fn value, acc ->
[acc, "\"", Protox.Encode.encode_string(value)]
end)
]
end
end
]
defp(encode_unknown_fields(acc, msg)) do
Enum.reduce(msg.__struct__.unknown_fields(msg), acc, fn {tag, wire_type, bytes}, acc ->
case(wire_type) do
0 ->
[acc, Protox.Encode.make_key_bytes(tag, :int32), bytes]
1 ->
[acc, Protox.Encode.make_key_bytes(tag, :double), bytes]
2 ->
len_bytes = bytes |> byte_size() |> Protox.Varint.encode()
[acc, Protox.Encode.make_key_bytes(tag, :packed), len_bytes, bytes]
5 ->
[acc, Protox.Encode.make_key_bytes(tag, :float), bytes]
end
end)
end
)
(
@spec decode(binary) :: {:ok, struct} | {:error, any}
def(decode(bytes)) do
try do
{:ok, decode!(bytes)}
rescue
Protox.IllegalTagError ->
{:error, :illegal_tag}
e in Protox.RequiredFieldsError ->
{:error, {:missing_fields, e.missing_fields}}
e in Protox.DecodingError ->
{:error, {e.reason, e.binary}}
e ->
{:error, e}
end
end
(
@spec decode!(binary) :: struct | no_return
def(decode!(bytes)) do
parse_key_value(bytes, struct(CucumberMessages.Pickle.PickleStep))
end
)
(
@spec parse_key_value(binary, struct) :: struct
defp(parse_key_value(<<>>, msg)) do
msg
end
defp(parse_key_value(bytes, msg)) do
{field, rest} =
case(Protox.Decode.parse_key(bytes)) do
{0, _, _} ->
raise(%Protox.IllegalTagError{})
{1, _, bytes} ->
{len, bytes} = Protox.Varint.decode(bytes)
<<delimited::binary-size(len), rest::binary>> = bytes
value = delimited
field = {:text, value}
{field, rest}
{2, _, bytes} ->
{len, bytes} = Protox.Varint.decode(bytes)
<<delimited::binary-size(len), rest::binary>> = bytes
value = CucumberMessages.PickleStepArgument.decode!(delimited)
field = {:argument, Protox.Message.merge(msg.argument(), value)}
{field, rest}
{3, _, bytes} ->
{len, bytes} = Protox.Varint.decode(bytes)
<<delimited::binary-size(len), rest::binary>> = bytes
value = delimited
field = {:id, value}
{field, rest}
{4, _, bytes} ->
{len, bytes} = Protox.Varint.decode(bytes)
<<delimited::binary-size(len), rest::binary>> = bytes
value = delimited
field = {:ast_node_ids, msg.ast_node_ids() ++ List.wrap(value)}
{field, rest}
{tag, wire_type, rest} ->
{value, new_rest} = Protox.Decode.parse_unknown(tag, wire_type, rest)
field =
{msg.__struct__.unknown_fields_name,
[value | msg.__struct__.unknown_fields(msg)]}
{field, new_rest}
end
msg_updated = struct(msg, [field])
parse_key_value(rest, msg_updated)
end
)
[]
)
@spec defs() :: %{
required(non_neg_integer) => {atom, Protox.Types.kind(), Protox.Types.type()}
}
def(defs()) do
%{
1 => {:text, {:default, ""}, :string},
2 => {:argument, {:default, nil}, {:message, CucumberMessages.PickleStepArgument}},
3 => {:id, {:default, ""}, :string},
4 => {:ast_node_ids, :unpacked, :string}
}
end
@spec defs_by_name() :: %{
required(atom) => {non_neg_integer, Protox.Types.kind(), Protox.Types.type()}
}
def(defs_by_name()) do
%{
argument: {2, {:default, nil}, {:message, CucumberMessages.PickleStepArgument}},
ast_node_ids: {4, :unpacked, :string},
id: {3, {:default, ""}, :string},
text: {1, {:default, ""}, :string}
}
end
@spec required_fields() :: []
def(required_fields()) do
[]
end
@spec unknown_fields(struct) :: [{non_neg_integer, Protox.Types.tag(), binary}]
def(unknown_fields(msg)) do
msg.__uf__()
end
@spec unknown_fields_name() :: :__uf__
def(unknown_fields_name()) do
:__uf__
end
@spec clear_unknown_fields(struct) :: struct
def(clear_unknown_fields(msg)) do
struct!(msg, [{unknown_fields_name(), []}])
end
@spec syntax() :: atom
def(syntax()) do
:proto3
end
[
@spec(
default(atom) :: {:ok, boolean | integer | String.t() | binary | float} | {:error, atom}
),
[
def(default(:text)) do
{:ok, ""}
end,
def(default(:argument)) do
{:ok, nil}
end,
def(default(:id)) do
{:ok, ""}
end,
def(default(:ast_node_ids)) do
{:error, :no_default_value}
end
],
def(default(_)) do
{:error, :no_such_field}
end
]
)
[]
end,
defmodule(CucumberMessages.TestCaseFinished) do
@moduledoc false
(
defstruct(timestamp: nil, test_case_started_id: "", __uf__: [])
(
@spec encode(struct) :: {:ok, iodata} | {:error, any}
def(encode(msg)) do
try do
{:ok, encode!(msg)}
rescue
e ->
{:error, e}
end
end
@spec encode!(struct) :: iodata | no_return
def(encode!(msg)) do
[]
|> encode_timestamp(msg)
|> encode_test_case_started_id(msg)
|> encode_unknown_fields(msg)
end
[]
[
defp(encode_timestamp(acc, msg)) do
field_value = msg.timestamp()
if(field_value == nil) do
acc
else
[acc, "\n", Protox.Encode.encode_message(field_value)]
end
end,
defp(encode_test_case_started_id(acc, msg)) do
field_value = msg.test_case_started_id()
if(field_value == "") do
acc
else
[acc, <<26>>, Protox.Encode.encode_string(field_value)]
end
end
]
defp(encode_unknown_fields(acc, msg)) do
Enum.reduce(msg.__struct__.unknown_fields(msg), acc, fn {tag, wire_type, bytes}, acc ->
case(wire_type) do
0 ->
[acc, Protox.Encode.make_key_bytes(tag, :int32), bytes]
1 ->
[acc, Protox.Encode.make_key_bytes(tag, :double), bytes]
2 ->
len_bytes = bytes |> byte_size() |> Protox.Varint.encode()
[acc, Protox.Encode.make_key_bytes(tag, :packed), len_bytes, bytes]
5 ->
[acc, Protox.Encode.make_key_bytes(tag, :float), bytes]
end
end)
end
)
(
@spec decode(binary) :: {:ok, struct} | {:error, any}
def(decode(bytes)) do
try do
{:ok, decode!(bytes)}
rescue
Protox.IllegalTagError ->
{:error, :illegal_tag}
e in Protox.RequiredFieldsError ->
{:error, {:missing_fields, e.missing_fields}}
e in Protox.DecodingError ->
{:error, {e.reason, e.binary}}
e ->
{:error, e}
end
end
(
@spec decode!(binary) :: struct | no_return
def(decode!(bytes)) do
parse_key_value(bytes, struct(CucumberMessages.TestCaseFinished))
end
)
(
@spec parse_key_value(binary, struct) :: struct
defp(parse_key_value(<<>>, msg)) do
msg
end
defp(parse_key_value(bytes, msg)) do
{field, rest} =
case(Protox.Decode.parse_key(bytes)) do
{0, _, _} ->
raise(%Protox.IllegalTagError{})
{1, _, bytes} ->
{len, bytes} = Protox.Varint.decode(bytes)
<<delimited::binary-size(len), rest::binary>> = bytes
value = CucumberMessages.Timestamp.decode!(delimited)
field = {:timestamp, Protox.Message.merge(msg.timestamp(), value)}
{field, rest}
{3, _, bytes} ->
{len, bytes} = Protox.Varint.decode(bytes)
<<delimited::binary-size(len), rest::binary>> = bytes
value = delimited
field = {:test_case_started_id, value}
{field, rest}
{tag, wire_type, rest} ->
{value, new_rest} = Protox.Decode.parse_unknown(tag, wire_type, rest)
field =
{msg.__struct__.unknown_fields_name,
[value | msg.__struct__.unknown_fields(msg)]}
{field, new_rest}
end
msg_updated = struct(msg, [field])
parse_key_value(rest, msg_updated)
end
)
[]
)
@spec defs() :: %{
required(non_neg_integer) => {atom, Protox.Types.kind(), Protox.Types.type()}
}
def(defs()) do
%{
1 => {:timestamp, {:default, nil}, {:message, CucumberMessages.Timestamp}},
3 => {:test_case_started_id, {:default, ""}, :string}
}
end
@spec defs_by_name() :: %{
required(atom) => {non_neg_integer, Protox.Types.kind(), Protox.Types.type()}
}
def(defs_by_name()) do
%{
test_case_started_id: {3, {:default, ""}, :string},
timestamp: {1, {:default, nil}, {:message, CucumberMessages.Timestamp}}
}
end
@spec required_fields() :: []
def(required_fields()) do
[]
end
@spec unknown_fields(struct) :: [{non_neg_integer, Protox.Types.tag(), binary}]
def(unknown_fields(msg)) do
msg.__uf__()
end
@spec unknown_fields_name() :: :__uf__
def(unknown_fields_name()) do
:__uf__
end
@spec clear_unknown_fields(struct) :: struct
def(clear_unknown_fields(msg)) do
struct!(msg, [{unknown_fields_name(), []}])
end
@spec syntax() :: atom
def(syntax()) do
:proto3
end
[
@spec(
default(atom) :: {:ok, boolean | integer | String.t() | binary | float} | {:error, atom}
),
[
def(default(:timestamp)) do
{:ok, nil}
end,
def(default(:test_case_started_id)) do
{:ok, ""}
end
],
def(default(_)) do
{:error, :no_such_field}
end
]
)
[]
end,
defmodule(CucumberMessages.GherkinDocument) do
@moduledoc false
(
defstruct(uri: "", feature: nil, comments: [], __uf__: [])
(
@spec encode(struct) :: {:ok, iodata} | {:error, any}
def(encode(msg)) do
try do
{:ok, encode!(msg)}
rescue
e ->
{:error, e}
end
end
@spec encode!(struct) :: iodata | no_return
def(encode!(msg)) do
[]
|> encode_uri(msg)
|> encode_feature(msg)
|> encode_comments(msg)
|> encode_unknown_fields(msg)
end
[]
[
defp(encode_uri(acc, msg)) do
field_value = msg.uri()
if(field_value == "") do
acc
else
[acc, "\n", Protox.Encode.encode_string(field_value)]
end
end,
defp(encode_feature(acc, msg)) do
field_value = msg.feature()
if(field_value == nil) do
acc
else
[acc, <<18>>, Protox.Encode.encode_message(field_value)]
end
end,
defp(encode_comments(acc, msg)) do
case(msg.comments()) do
[] ->
acc
values ->
[
acc,
Enum.reduce(values, [], fn value, acc ->
[acc, <<26>>, Protox.Encode.encode_message(value)]
end)
]
end
end
]
defp(encode_unknown_fields(acc, msg)) do
Enum.reduce(msg.__struct__.unknown_fields(msg), acc, fn {tag, wire_type, bytes}, acc ->
case(wire_type) do
0 ->
[acc, Protox.Encode.make_key_bytes(tag, :int32), bytes]
1 ->
[acc, Protox.Encode.make_key_bytes(tag, :double), bytes]
2 ->
len_bytes = bytes |> byte_size() |> Protox.Varint.encode()
[acc, Protox.Encode.make_key_bytes(tag, :packed), len_bytes, bytes]
5 ->
[acc, Protox.Encode.make_key_bytes(tag, :float), bytes]
end
end)
end
)
(
@spec decode(binary) :: {:ok, struct} | {:error, any}
def(decode(bytes)) do
try do
{:ok, decode!(bytes)}
rescue
Protox.IllegalTagError ->
{:error, :illegal_tag}
e in Protox.RequiredFieldsError ->
{:error, {:missing_fields, e.missing_fields}}
e in Protox.DecodingError ->
{:error, {e.reason, e.binary}}
e ->
{:error, e}
end
end
(
@spec decode!(binary) :: struct | no_return
def(decode!(bytes)) do
parse_key_value(bytes, struct(CucumberMessages.GherkinDocument))
end
)
(
@spec parse_key_value(binary, struct) :: struct
defp(parse_key_value(<<>>, msg)) do
msg
end
defp(parse_key_value(bytes, msg)) do
{field, rest} =
case(Protox.Decode.parse_key(bytes)) do
{0, _, _} ->
raise(%Protox.IllegalTagError{})
{1, _, bytes} ->
{len, bytes} = Protox.Varint.decode(bytes)
<<delimited::binary-size(len), rest::binary>> = bytes
value = delimited
field = {:uri, value}
{field, rest}
{2, _, bytes} ->
{len, bytes} = Protox.Varint.decode(bytes)
<<delimited::binary-size(len), rest::binary>> = bytes
value = CucumberMessages.GherkinDocument.Feature.decode!(delimited)
field = {:feature, Protox.Message.merge(msg.feature(), value)}
{field, rest}
{3, _, bytes} ->
{len, bytes} = Protox.Varint.decode(bytes)
<<delimited::binary-size(len), rest::binary>> = bytes
value = CucumberMessages.GherkinDocument.Comment.decode!(delimited)
field = {:comments, msg.comments() ++ List.wrap(value)}
{field, rest}
{tag, wire_type, rest} ->
{value, new_rest} = Protox.Decode.parse_unknown(tag, wire_type, rest)
field =
{msg.__struct__.unknown_fields_name,
[value | msg.__struct__.unknown_fields(msg)]}
{field, new_rest}
end
msg_updated = struct(msg, [field])
parse_key_value(rest, msg_updated)
end
)
[]
)
@spec defs() :: %{
required(non_neg_integer) => {atom, Protox.Types.kind(), Protox.Types.type()}
}
def(defs()) do
%{
1 => {:uri, {:default, ""}, :string},
2 => {:feature, {:default, nil}, {:message, CucumberMessages.GherkinDocument.Feature}},
3 => {:comments, :unpacked, {:message, CucumberMessages.GherkinDocument.Comment}}
}
end
@spec defs_by_name() :: %{
required(atom) => {non_neg_integer, Protox.Types.kind(), Protox.Types.type()}
}
def(defs_by_name()) do
%{
comments: {3, :unpacked, {:message, CucumberMessages.GherkinDocument.Comment}},
feature: {2, {:default, nil}, {:message, CucumberMessages.GherkinDocument.Feature}},
uri: {1, {:default, ""}, :string}
}
end
@spec required_fields() :: []
def(required_fields()) do
[]
end
@spec unknown_fields(struct) :: [{non_neg_integer, Protox.Types.tag(), binary}]
def(unknown_fields(msg)) do
msg.__uf__()
end
@spec unknown_fields_name() :: :__uf__
def(unknown_fields_name()) do
:__uf__
end
@spec clear_unknown_fields(struct) :: struct
def(clear_unknown_fields(msg)) do
struct!(msg, [{unknown_fields_name(), []}])
end
@spec syntax() :: atom
def(syntax()) do
:proto3
end
[
@spec(
default(atom) :: {:ok, boolean | integer | String.t() | binary | float} | {:error, atom}
),
[
def(default(:uri)) do
{:ok, ""}
end,
def(default(:feature)) do
{:ok, nil}
end,
def(default(:comments)) do
{:error, :no_default_value}
end
],
def(default(_)) do
{:error, :no_such_field}
end
]
)
[]
end,
defmodule(CucumberMessages.Hook) do
@moduledoc false
(
defstruct(id: "", tag_expression: "", source_reference: nil, __uf__: [])
(
@spec encode(struct) :: {:ok, iodata} | {:error, any}
def(encode(msg)) do
try do
{:ok, encode!(msg)}
rescue
e ->
{:error, e}
end
end
@spec encode!(struct) :: iodata | no_return
def(encode!(msg)) do
[]
|> encode_id(msg)
|> encode_tag_expression(msg)
|> encode_source_reference(msg)
|> encode_unknown_fields(msg)
end
[]
[
defp(encode_id(acc, msg)) do
field_value = msg.id()
if(field_value == "") do
acc
else
[acc, "\n", Protox.Encode.encode_string(field_value)]
end
end,
defp(encode_tag_expression(acc, msg)) do
field_value = msg.tag_expression()
if(field_value == "") do
acc
else
[acc, <<18>>, Protox.Encode.encode_string(field_value)]
end
end,
defp(encode_source_reference(acc, msg)) do
field_value = msg.source_reference()
if(field_value == nil) do
acc
else
[acc, <<26>>, Protox.Encode.encode_message(field_value)]
end
end
]
defp(encode_unknown_fields(acc, msg)) do
Enum.reduce(msg.__struct__.unknown_fields(msg), acc, fn {tag, wire_type, bytes}, acc ->
case(wire_type) do
0 ->
[acc, Protox.Encode.make_key_bytes(tag, :int32), bytes]
1 ->
[acc, Protox.Encode.make_key_bytes(tag, :double), bytes]
2 ->
len_bytes = bytes |> byte_size() |> Protox.Varint.encode()
[acc, Protox.Encode.make_key_bytes(tag, :packed), len_bytes, bytes]
5 ->
[acc, Protox.Encode.make_key_bytes(tag, :float), bytes]
end
end)
end
)
(
@spec decode(binary) :: {:ok, struct} | {:error, any}
def(decode(bytes)) do
try do
{:ok, decode!(bytes)}
rescue
Protox.IllegalTagError ->
{:error, :illegal_tag}
e in Protox.RequiredFieldsError ->
{:error, {:missing_fields, e.missing_fields}}
e in Protox.DecodingError ->
{:error, {e.reason, e.binary}}
e ->
{:error, e}
end
end
(
@spec decode!(binary) :: struct | no_return
def(decode!(bytes)) do
parse_key_value(bytes, struct(CucumberMessages.Hook))
end
)
(
@spec parse_key_value(binary, struct) :: struct
defp(parse_key_value(<<>>, msg)) do
msg
end
defp(parse_key_value(bytes, msg)) do
{field, rest} =
case(Protox.Decode.parse_key(bytes)) do
{0, _, _} ->
raise(%Protox.IllegalTagError{})
{1, _, bytes} ->
{len, bytes} = Protox.Varint.decode(bytes)
<<delimited::binary-size(len), rest::binary>> = bytes
value = delimited
field = {:id, value}
{field, rest}
{2, _, bytes} ->
{len, bytes} = Protox.Varint.decode(bytes)
<<delimited::binary-size(len), rest::binary>> = bytes
value = delimited
field = {:tag_expression, value}
{field, rest}
{3, _, bytes} ->
{len, bytes} = Protox.Varint.decode(bytes)
<<delimited::binary-size(len), rest::binary>> = bytes
value = CucumberMessages.SourceReference.decode!(delimited)
field = {:source_reference, Protox.Message.merge(msg.source_reference(), value)}
{field, rest}
{tag, wire_type, rest} ->
{value, new_rest} = Protox.Decode.parse_unknown(tag, wire_type, rest)
field =
{msg.__struct__.unknown_fields_name,
[value | msg.__struct__.unknown_fields(msg)]}
{field, new_rest}
end
msg_updated = struct(msg, [field])
parse_key_value(rest, msg_updated)
end
)
[]
)
@spec defs() :: %{
required(non_neg_integer) => {atom, Protox.Types.kind(), Protox.Types.type()}
}
def(defs()) do
%{
1 => {:id, {:default, ""}, :string},
2 => {:tag_expression, {:default, ""}, :string},
3 => {:source_reference, {:default, nil}, {:message, CucumberMessages.SourceReference}}
}
end
@spec defs_by_name() :: %{
required(atom) => {non_neg_integer, Protox.Types.kind(), Protox.Types.type()}
}
def(defs_by_name()) do
%{
id: {1, {:default, ""}, :string},
source_reference: {3, {:default, nil}, {:message, CucumberMessages.SourceReference}},
tag_expression: {2, {:default, ""}, :string}
}
end
@spec required_fields() :: []
def(required_fields()) do
[]
end
@spec unknown_fields(struct) :: [{non_neg_integer, Protox.Types.tag(), binary}]
def(unknown_fields(msg)) do
msg.__uf__()
end
@spec unknown_fields_name() :: :__uf__
def(unknown_fields_name()) do
:__uf__
end
@spec clear_unknown_fields(struct) :: struct
def(clear_unknown_fields(msg)) do
struct!(msg, [{unknown_fields_name(), []}])
end
@spec syntax() :: atom
def(syntax()) do
:proto3
end
[
@spec(
default(atom) :: {:ok, boolean | integer | String.t() | binary | float} | {:error, atom}
),
[
def(default(:id)) do
{:ok, ""}
end,
def(default(:tag_expression)) do
{:ok, ""}
end,
def(default(:source_reference)) do
{:ok, nil}
end
],
def(default(_)) do
{:error, :no_such_field}
end
]
)
[]
end,
defmodule(CucumberMessages.Pickle) do
@moduledoc false
(
defstruct(
id: "",
uri: "",
name: "",
language: "",
steps: [],
tags: [],
ast_node_ids: [],
__uf__: []
)
(
@spec encode(struct) :: {:ok, iodata} | {:error, any}
def(encode(msg)) do
try do
{:ok, encode!(msg)}
rescue
e ->
{:error, e}
end
end
@spec encode!(struct) :: iodata | no_return
def(encode!(msg)) do
[]
|> encode_id(msg)
|> encode_uri(msg)
|> encode_name(msg)
|> encode_language(msg)
|> encode_steps(msg)
|> encode_tags(msg)
|> encode_ast_node_ids(msg)
|> encode_unknown_fields(msg)
end
[]
[
defp(encode_id(acc, msg)) do
field_value = msg.id()
if(field_value == "") do
acc
else
[acc, "\n", Protox.Encode.encode_string(field_value)]
end
end,
defp(encode_uri(acc, msg)) do
field_value = msg.uri()
if(field_value == "") do
acc
else
[acc, <<18>>, Protox.Encode.encode_string(field_value)]
end
end,
defp(encode_name(acc, msg)) do
field_value = msg.name()
if(field_value == "") do
acc
else
[acc, <<26>>, Protox.Encode.encode_string(field_value)]
end
end,
defp(encode_language(acc, msg)) do
field_value = msg.language()
if(field_value == "") do
acc
else
[acc, "\"", Protox.Encode.encode_string(field_value)]
end
end,
defp(encode_steps(acc, msg)) do
case(msg.steps()) do
[] ->
acc
values ->
[
acc,
Enum.reduce(values, [], fn value, acc ->
[acc, "*", Protox.Encode.encode_message(value)]
end)
]
end
end,
defp(encode_tags(acc, msg)) do
case(msg.tags()) do
[] ->
acc
values ->
[
acc,
Enum.reduce(values, [], fn value, acc ->
[acc, "2", Protox.Encode.encode_message(value)]
end)
]
end
end,
defp(encode_ast_node_ids(acc, msg)) do
case(msg.ast_node_ids()) do
[] ->
acc
values ->
[
acc,
Enum.reduce(values, [], fn value, acc ->
[acc, ":", Protox.Encode.encode_string(value)]
end)
]
end
end
]
defp(encode_unknown_fields(acc, msg)) do
Enum.reduce(msg.__struct__.unknown_fields(msg), acc, fn {tag, wire_type, bytes}, acc ->
case(wire_type) do
0 ->
[acc, Protox.Encode.make_key_bytes(tag, :int32), bytes]
1 ->
[acc, Protox.Encode.make_key_bytes(tag, :double), bytes]
2 ->
len_bytes = bytes |> byte_size() |> Protox.Varint.encode()
[acc, Protox.Encode.make_key_bytes(tag, :packed), len_bytes, bytes]
5 ->
[acc, Protox.Encode.make_key_bytes(tag, :float), bytes]
end
end)
end
)
(
@spec decode(binary) :: {:ok, struct} | {:error, any}
def(decode(bytes)) do
try do
{:ok, decode!(bytes)}
rescue
Protox.IllegalTagError ->
{:error, :illegal_tag}
e in Protox.RequiredFieldsError ->
{:error, {:missing_fields, e.missing_fields}}
e in Protox.DecodingError ->
{:error, {e.reason, e.binary}}
e ->
{:error, e}
end
end
(
@spec decode!(binary) :: struct | no_return
def(decode!(bytes)) do
parse_key_value(bytes, struct(CucumberMessages.Pickle))
end
)
(
@spec parse_key_value(binary, struct) :: struct
defp(parse_key_value(<<>>, msg)) do
msg
end
defp(parse_key_value(bytes, msg)) do
{field, rest} =
case(Protox.Decode.parse_key(bytes)) do
{0, _, _} ->
raise(%Protox.IllegalTagError{})
{1, _, bytes} ->
{len, bytes} = Protox.Varint.decode(bytes)
<<delimited::binary-size(len), rest::binary>> = bytes
value = delimited
field = {:id, value}
{field, rest}
{2, _, bytes} ->
{len, bytes} = Protox.Varint.decode(bytes)
<<delimited::binary-size(len), rest::binary>> = bytes
value = delimited
field = {:uri, value}
{field, rest}
{3, _, bytes} ->
{len, bytes} = Protox.Varint.decode(bytes)
<<delimited::binary-size(len), rest::binary>> = bytes
value = delimited
field = {:name, value}
{field, rest}
{4, _, bytes} ->
{len, bytes} = Protox.Varint.decode(bytes)
<<delimited::binary-size(len), rest::binary>> = bytes
value = delimited
field = {:language, value}
{field, rest}
{5, _, bytes} ->
{len, bytes} = Protox.Varint.decode(bytes)
<<delimited::binary-size(len), rest::binary>> = bytes
value = CucumberMessages.Pickle.PickleStep.decode!(delimited)
field = {:steps, msg.steps() ++ List.wrap(value)}
{field, rest}
{6, _, bytes} ->
{len, bytes} = Protox.Varint.decode(bytes)
<<delimited::binary-size(len), rest::binary>> = bytes
value = CucumberMessages.Pickle.PickleTag.decode!(delimited)
field = {:tags, msg.tags() ++ List.wrap(value)}
{field, rest}
{7, _, bytes} ->
{len, bytes} = Protox.Varint.decode(bytes)
<<delimited::binary-size(len), rest::binary>> = bytes
value = delimited
field = {:ast_node_ids, msg.ast_node_ids() ++ List.wrap(value)}
{field, rest}
{tag, wire_type, rest} ->
{value, new_rest} = Protox.Decode.parse_unknown(tag, wire_type, rest)
field =
{msg.__struct__.unknown_fields_name,
[value | msg.__struct__.unknown_fields(msg)]}
{field, new_rest}
end
msg_updated = struct(msg, [field])
parse_key_value(rest, msg_updated)
end
)
[]
)
@spec defs() :: %{
required(non_neg_integer) => {atom, Protox.Types.kind(), Protox.Types.type()}
}
def(defs()) do
%{
1 => {:id, {:default, ""}, :string},
2 => {:uri, {:default, ""}, :string},
3 => {:name, {:default, ""}, :string},
4 => {:language, {:default, ""}, :string},
5 => {:steps, :unpacked, {:message, CucumberMessages.Pickle.PickleStep}},
6 => {:tags, :unpacked, {:message, CucumberMessages.Pickle.PickleTag}},
7 => {:ast_node_ids, :unpacked, :string}
}
end
@spec defs_by_name() :: %{
required(atom) => {non_neg_integer, Protox.Types.kind(), Protox.Types.type()}
}
def(defs_by_name()) do
%{
ast_node_ids: {7, :unpacked, :string},
id: {1, {:default, ""}, :string},
language: {4, {:default, ""}, :string},
name: {3, {:default, ""}, :string},
steps: {5, :unpacked, {:message, CucumberMessages.Pickle.PickleStep}},
tags: {6, :unpacked, {:message, CucumberMessages.Pickle.PickleTag}},
uri: {2, {:default, ""}, :string}
}
end
@spec required_fields() :: []
def(required_fields()) do
[]
end
@spec unknown_fields(struct) :: [{non_neg_integer, Protox.Types.tag(), binary}]
def(unknown_fields(msg)) do
msg.__uf__()
end
@spec unknown_fields_name() :: :__uf__
def(unknown_fields_name()) do
:__uf__
end
@spec clear_unknown_fields(struct) :: struct
def(clear_unknown_fields(msg)) do
struct!(msg, [{unknown_fields_name(), []}])
end
@spec syntax() :: atom
def(syntax()) do
:proto3
end
[
@spec(
default(atom) :: {:ok, boolean | integer | String.t() | binary | float} | {:error, atom}
),
[
def(default(:id)) do
{:ok, ""}
end,
def(default(:uri)) do
{:ok, ""}
end,
def(default(:name)) do
{:ok, ""}
end,
def(default(:language)) do
{:ok, ""}
end,
def(default(:steps)) do
{:error, :no_default_value}
end,
def(default(:tags)) do
{:error, :no_default_value}
end,
def(default(:ast_node_ids)) do
{:error, :no_default_value}
end
],
def(default(_)) do
{:error, :no_such_field}
end
]
)
[]
end,
defmodule(CucumberMessages.Location) do
@moduledoc false
(
defstruct(line: 0, column: 0, __uf__: [])
(
@spec encode(struct) :: {:ok, iodata} | {:error, any}
def(encode(msg)) do
try do
{:ok, encode!(msg)}
rescue
e ->
{:error, e}
end
end
@spec encode!(struct) :: iodata | no_return
def(encode!(msg)) do
[] |> encode_line(msg) |> encode_column(msg) |> encode_unknown_fields(msg)
end
[]
[
defp(encode_line(acc, msg)) do
field_value = msg.line()
if(field_value == 0) do
acc
else
[acc, "\b", Protox.Encode.encode_uint32(field_value)]
end
end,
defp(encode_column(acc, msg)) do
field_value = msg.column()
if(field_value == 0) do
acc
else
[acc, <<16>>, Protox.Encode.encode_uint32(field_value)]
end
end
]
defp(encode_unknown_fields(acc, msg)) do
Enum.reduce(msg.__struct__.unknown_fields(msg), acc, fn {tag, wire_type, bytes}, acc ->
case(wire_type) do
0 ->
[acc, Protox.Encode.make_key_bytes(tag, :int32), bytes]
1 ->
[acc, Protox.Encode.make_key_bytes(tag, :double), bytes]
2 ->
len_bytes = bytes |> byte_size() |> Protox.Varint.encode()
[acc, Protox.Encode.make_key_bytes(tag, :packed), len_bytes, bytes]
5 ->
[acc, Protox.Encode.make_key_bytes(tag, :float), bytes]
end
end)
end
)
(
@spec decode(binary) :: {:ok, struct} | {:error, any}
def(decode(bytes)) do
try do
{:ok, decode!(bytes)}
rescue
Protox.IllegalTagError ->
{:error, :illegal_tag}
e in Protox.RequiredFieldsError ->
{:error, {:missing_fields, e.missing_fields}}
e in Protox.DecodingError ->
{:error, {e.reason, e.binary}}
e ->
{:error, e}
end
end
(
@spec decode!(binary) :: struct | no_return
def(decode!(bytes)) do
parse_key_value(bytes, struct(CucumberMessages.Location))
end
)
(
@spec parse_key_value(binary, struct) :: struct
defp(parse_key_value(<<>>, msg)) do
msg
end
defp(parse_key_value(bytes, msg)) do
{field, rest} =
case(Protox.Decode.parse_key(bytes)) do
{0, _, _} ->
raise(%Protox.IllegalTagError{})
{1, _, bytes} ->
{value, rest} = Protox.Decode.parse_uint32(bytes)
field = {:line, value}
{field, rest}
{2, _, bytes} ->
{value, rest} = Protox.Decode.parse_uint32(bytes)
field = {:column, value}
{field, rest}
{tag, wire_type, rest} ->
{value, new_rest} = Protox.Decode.parse_unknown(tag, wire_type, rest)
field =
{msg.__struct__.unknown_fields_name,
[value | msg.__struct__.unknown_fields(msg)]}
{field, new_rest}
end
msg_updated = struct(msg, [field])
parse_key_value(rest, msg_updated)
end
)
[]
)
@spec defs() :: %{
required(non_neg_integer) => {atom, Protox.Types.kind(), Protox.Types.type()}
}
def(defs()) do
%{1 => {:line, {:default, 0}, :uint32}, 2 => {:column, {:default, 0}, :uint32}}
end
@spec defs_by_name() :: %{
required(atom) => {non_neg_integer, Protox.Types.kind(), Protox.Types.type()}
}
def(defs_by_name()) do
%{column: {2, {:default, 0}, :uint32}, line: {1, {:default, 0}, :uint32}}
end
@spec required_fields() :: []
def(required_fields()) do
[]
end
@spec unknown_fields(struct) :: [{non_neg_integer, Protox.Types.tag(), binary}]
def(unknown_fields(msg)) do
msg.__uf__()
end
@spec unknown_fields_name() :: :__uf__
def(unknown_fields_name()) do
:__uf__
end
@spec clear_unknown_fields(struct) :: struct
def(clear_unknown_fields(msg)) do
struct!(msg, [{unknown_fields_name(), []}])
end
@spec syntax() :: atom
def(syntax()) do
:proto3
end
[
@spec(
default(atom) :: {:ok, boolean | integer | String.t() | binary | float} | {:error, atom}
),
[
def(default(:line)) do
{:ok, 0}
end,
def(default(:column)) do
{:ok, 0}
end
],
def(default(_)) do
{:error, :no_such_field}
end
]
)
[]
end,
defmodule(CucumberMessages.Meta.Product) do
@moduledoc false
(
defstruct(name: "", version: "", __uf__: [])
(
@spec encode(struct) :: {:ok, iodata} | {:error, any}
def(encode(msg)) do
try do
{:ok, encode!(msg)}
rescue
e ->
{:error, e}
end
end
@spec encode!(struct) :: iodata | no_return
def(encode!(msg)) do
[] |> encode_name(msg) |> encode_version(msg) |> encode_unknown_fields(msg)
end
[]
[
defp(encode_name(acc, msg)) do
field_value = msg.name()
if(field_value == "") do
acc
else
[acc, "\n", Protox.Encode.encode_string(field_value)]
end
end,
defp(encode_version(acc, msg)) do
field_value = msg.version()
if(field_value == "") do
acc
else
[acc, <<18>>, Protox.Encode.encode_string(field_value)]
end
end
]
defp(encode_unknown_fields(acc, msg)) do
Enum.reduce(msg.__struct__.unknown_fields(msg), acc, fn {tag, wire_type, bytes}, acc ->
case(wire_type) do
0 ->
[acc, Protox.Encode.make_key_bytes(tag, :int32), bytes]
1 ->
[acc, Protox.Encode.make_key_bytes(tag, :double), bytes]
2 ->
len_bytes = bytes |> byte_size() |> Protox.Varint.encode()
[acc, Protox.Encode.make_key_bytes(tag, :packed), len_bytes, bytes]
5 ->
[acc, Protox.Encode.make_key_bytes(tag, :float), bytes]
end
end)
end
)
(
@spec decode(binary) :: {:ok, struct} | {:error, any}
def(decode(bytes)) do
try do
{:ok, decode!(bytes)}
rescue
Protox.IllegalTagError ->
{:error, :illegal_tag}
e in Protox.RequiredFieldsError ->
{:error, {:missing_fields, e.missing_fields}}
e in Protox.DecodingError ->
{:error, {e.reason, e.binary}}
e ->
{:error, e}
end
end
(
@spec decode!(binary) :: struct | no_return
def(decode!(bytes)) do
parse_key_value(bytes, struct(CucumberMessages.Meta.Product))
end
)
(
@spec parse_key_value(binary, struct) :: struct
defp(parse_key_value(<<>>, msg)) do
msg
end
defp(parse_key_value(bytes, msg)) do
{field, rest} =
case(Protox.Decode.parse_key(bytes)) do
{0, _, _} ->
raise(%Protox.IllegalTagError{})
{1, _, bytes} ->
{len, bytes} = Protox.Varint.decode(bytes)
<<delimited::binary-size(len), rest::binary>> = bytes
value = delimited
field = {:name, value}
{field, rest}
{2, _, bytes} ->
{len, bytes} = Protox.Varint.decode(bytes)
<<delimited::binary-size(len), rest::binary>> = bytes
value = delimited
field = {:version, value}
{field, rest}
{tag, wire_type, rest} ->
{value, new_rest} = Protox.Decode.parse_unknown(tag, wire_type, rest)
field =
{msg.__struct__.unknown_fields_name,
[value | msg.__struct__.unknown_fields(msg)]}
{field, new_rest}
end
msg_updated = struct(msg, [field])
parse_key_value(rest, msg_updated)
end
)
[]
)
@spec defs() :: %{
required(non_neg_integer) => {atom, Protox.Types.kind(), Protox.Types.type()}
}
def(defs()) do
%{1 => {:name, {:default, ""}, :string}, 2 => {:version, {:default, ""}, :string}}
end
@spec defs_by_name() :: %{
required(atom) => {non_neg_integer, Protox.Types.kind(), Protox.Types.type()}
}
def(defs_by_name()) do
%{name: {1, {:default, ""}, :string}, version: {2, {:default, ""}, :string}}
end
@spec required_fields() :: []
def(required_fields()) do
[]
end
@spec unknown_fields(struct) :: [{non_neg_integer, Protox.Types.tag(), binary}]
def(unknown_fields(msg)) do
msg.__uf__()
end
@spec unknown_fields_name() :: :__uf__
def(unknown_fields_name()) do
:__uf__
end
@spec clear_unknown_fields(struct) :: struct
def(clear_unknown_fields(msg)) do
struct!(msg, [{unknown_fields_name(), []}])
end
@spec syntax() :: atom
def(syntax()) do
:proto3
end
[
@spec(
default(atom) :: {:ok, boolean | integer | String.t() | binary | float} | {:error, atom}
),
[
def(default(:name)) do
{:ok, ""}
end,
def(default(:version)) do
{:ok, ""}
end
],
def(default(_)) do
{:error, :no_such_field}
end
]
)
[]
end,
defmodule(CucumberMessages.StepDefinition) do
@moduledoc false
(
defstruct(id: "", pattern: nil, source_reference: nil, __uf__: [])
(
@spec encode(struct) :: {:ok, iodata} | {:error, any}
def(encode(msg)) do
try do
{:ok, encode!(msg)}
rescue
e ->
{:error, e}
end
end
@spec encode!(struct) :: iodata | no_return
def(encode!(msg)) do
[]
|> encode_id(msg)
|> encode_pattern(msg)
|> encode_source_reference(msg)
|> encode_unknown_fields(msg)
end
[]
[
defp(encode_id(acc, msg)) do
field_value = msg.id()
if(field_value == "") do
acc
else
[acc, "\n", Protox.Encode.encode_string(field_value)]
end
end,
defp(encode_pattern(acc, msg)) do
field_value = msg.pattern()
if(field_value == nil) do
acc
else
[acc, <<18>>, Protox.Encode.encode_message(field_value)]
end
end,
defp(encode_source_reference(acc, msg)) do
field_value = msg.source_reference()
if(field_value == nil) do
acc
else
[acc, <<26>>, Protox.Encode.encode_message(field_value)]
end
end
]
defp(encode_unknown_fields(acc, msg)) do
Enum.reduce(msg.__struct__.unknown_fields(msg), acc, fn {tag, wire_type, bytes}, acc ->
case(wire_type) do
0 ->
[acc, Protox.Encode.make_key_bytes(tag, :int32), bytes]
1 ->
[acc, Protox.Encode.make_key_bytes(tag, :double), bytes]
2 ->
len_bytes = bytes |> byte_size() |> Protox.Varint.encode()
[acc, Protox.Encode.make_key_bytes(tag, :packed), len_bytes, bytes]
5 ->
[acc, Protox.Encode.make_key_bytes(tag, :float), bytes]
end
end)
end
)
(
@spec decode(binary) :: {:ok, struct} | {:error, any}
def(decode(bytes)) do
try do
{:ok, decode!(bytes)}
rescue
Protox.IllegalTagError ->
{:error, :illegal_tag}
e in Protox.RequiredFieldsError ->
{:error, {:missing_fields, e.missing_fields}}
e in Protox.DecodingError ->
{:error, {e.reason, e.binary}}
e ->
{:error, e}
end
end
(
@spec decode!(binary) :: struct | no_return
def(decode!(bytes)) do
parse_key_value(bytes, struct(CucumberMessages.StepDefinition))
end
)
(
@spec parse_key_value(binary, struct) :: struct
defp(parse_key_value(<<>>, msg)) do
msg
end
defp(parse_key_value(bytes, msg)) do
{field, rest} =
case(Protox.Decode.parse_key(bytes)) do
{0, _, _} ->
raise(%Protox.IllegalTagError{})
{1, _, bytes} ->
{len, bytes} = Protox.Varint.decode(bytes)
<<delimited::binary-size(len), rest::binary>> = bytes
value = delimited
field = {:id, value}
{field, rest}
{2, _, bytes} ->
{len, bytes} = Protox.Varint.decode(bytes)
<<delimited::binary-size(len), rest::binary>> = bytes
value = CucumberMessages.StepDefinition.StepDefinitionPattern.decode!(delimited)
field = {:pattern, Protox.Message.merge(msg.pattern(), value)}
{field, rest}
{3, _, bytes} ->
{len, bytes} = Protox.Varint.decode(bytes)
<<delimited::binary-size(len), rest::binary>> = bytes
value = CucumberMessages.SourceReference.decode!(delimited)
field = {:source_reference, Protox.Message.merge(msg.source_reference(), value)}
{field, rest}
{tag, wire_type, rest} ->
{value, new_rest} = Protox.Decode.parse_unknown(tag, wire_type, rest)
field =
{msg.__struct__.unknown_fields_name,
[value | msg.__struct__.unknown_fields(msg)]}
{field, new_rest}
end
msg_updated = struct(msg, [field])
parse_key_value(rest, msg_updated)
end
)
[]
)
@spec defs() :: %{
required(non_neg_integer) => {atom, Protox.Types.kind(), Protox.Types.type()}
}
def(defs()) do
%{
1 => {:id, {:default, ""}, :string},
2 =>
{:pattern, {:default, nil},
{:message, CucumberMessages.StepDefinition.StepDefinitionPattern}},
3 => {:source_reference, {:default, nil}, {:message, CucumberMessages.SourceReference}}
}
end
@spec defs_by_name() :: %{
required(atom) => {non_neg_integer, Protox.Types.kind(), Protox.Types.type()}
}
def(defs_by_name()) do
%{
id: {1, {:default, ""}, :string},
pattern:
{2, {:default, nil},
{:message, CucumberMessages.StepDefinition.StepDefinitionPattern}},
source_reference: {3, {:default, nil}, {:message, CucumberMessages.SourceReference}}
}
end
@spec required_fields() :: []
def(required_fields()) do
[]
end
@spec unknown_fields(struct) :: [{non_neg_integer, Protox.Types.tag(), binary}]
def(unknown_fields(msg)) do
msg.__uf__()
end
@spec unknown_fields_name() :: :__uf__
def(unknown_fields_name()) do
:__uf__
end
@spec clear_unknown_fields(struct) :: struct
def(clear_unknown_fields(msg)) do
struct!(msg, [{unknown_fields_name(), []}])
end
@spec syntax() :: atom
def(syntax()) do
:proto3
end
[
@spec(
default(atom) :: {:ok, boolean | integer | String.t() | binary | float} | {:error, atom}
),
[
def(default(:id)) do
{:ok, ""}
end,
def(default(:pattern)) do
{:ok, nil}
end,
def(default(:source_reference)) do
{:ok, nil}
end
],
def(default(_)) do
{:error, :no_such_field}
end
]
)
[]
end,
defmodule(CucumberMessages.TestCase.TestStep.StepMatchArgumentsList.StepMatchArgument) do
@moduledoc false
(
defstruct(parameter_type_name: "", group: nil, __uf__: [])
(
@spec encode(struct) :: {:ok, iodata} | {:error, any}
def(encode(msg)) do
try do
{:ok, encode!(msg)}
rescue
e ->
{:error, e}
end
end
@spec encode!(struct) :: iodata | no_return
def(encode!(msg)) do
[] |> encode_parameter_type_name(msg) |> encode_group(msg) |> encode_unknown_fields(msg)
end
[]
[
defp(encode_parameter_type_name(acc, msg)) do
field_value = msg.parameter_type_name()
if(field_value == "") do
acc
else
[acc, "\n", Protox.Encode.encode_string(field_value)]
end
end,
defp(encode_group(acc, msg)) do
field_value = msg.group()
if(field_value == nil) do
acc
else
[acc, <<18>>, Protox.Encode.encode_message(field_value)]
end
end
]
defp(encode_unknown_fields(acc, msg)) do
Enum.reduce(msg.__struct__.unknown_fields(msg), acc, fn {tag, wire_type, bytes}, acc ->
case(wire_type) do
0 ->
[acc, Protox.Encode.make_key_bytes(tag, :int32), bytes]
1 ->
[acc, Protox.Encode.make_key_bytes(tag, :double), bytes]
2 ->
len_bytes = bytes |> byte_size() |> Protox.Varint.encode()
[acc, Protox.Encode.make_key_bytes(tag, :packed), len_bytes, bytes]
5 ->
[acc, Protox.Encode.make_key_bytes(tag, :float), bytes]
end
end)
end
)
(
@spec decode(binary) :: {:ok, struct} | {:error, any}
def(decode(bytes)) do
try do
{:ok, decode!(bytes)}
rescue
Protox.IllegalTagError ->
{:error, :illegal_tag}
e in Protox.RequiredFieldsError ->
{:error, {:missing_fields, e.missing_fields}}
e in Protox.DecodingError ->
{:error, {e.reason, e.binary}}
e ->
{:error, e}
end
end
(
@spec decode!(binary) :: struct | no_return
def(decode!(bytes)) do
parse_key_value(
bytes,
struct(CucumberMessages.TestCase.TestStep.StepMatchArgumentsList.StepMatchArgument)
)
end
)
(
@spec parse_key_value(binary, struct) :: struct
defp(parse_key_value(<<>>, msg)) do
msg
end
defp(parse_key_value(bytes, msg)) do
{field, rest} =
case(Protox.Decode.parse_key(bytes)) do
{0, _, _} ->
raise(%Protox.IllegalTagError{})
{1, _, bytes} ->
{len, bytes} = Protox.Varint.decode(bytes)
<<delimited::binary-size(len), rest::binary>> = bytes
value = delimited
field = {:parameter_type_name, value}
{field, rest}
{2, _, bytes} ->
{len, bytes} = Protox.Varint.decode(bytes)
<<delimited::binary-size(len), rest::binary>> = bytes
value =
CucumberMessages.TestCase.TestStep.StepMatchArgumentsList.StepMatchArgument.Group.decode!(
delimited
)
field = {:group, Protox.Message.merge(msg.group(), value)}
{field, rest}
{tag, wire_type, rest} ->
{value, new_rest} = Protox.Decode.parse_unknown(tag, wire_type, rest)
field =
{msg.__struct__.unknown_fields_name,
[value | msg.__struct__.unknown_fields(msg)]}
{field, new_rest}
end
msg_updated = struct(msg, [field])
parse_key_value(rest, msg_updated)
end
)
[]
)
@spec defs() :: %{
required(non_neg_integer) => {atom, Protox.Types.kind(), Protox.Types.type()}
}
def(defs()) do
%{
1 => {:parameter_type_name, {:default, ""}, :string},
2 =>
{:group, {:default, nil},
{:message,
CucumberMessages.TestCase.TestStep.StepMatchArgumentsList.StepMatchArgument.Group}}
}
end
@spec defs_by_name() :: %{
required(atom) => {non_neg_integer, Protox.Types.kind(), Protox.Types.type()}
}
def(defs_by_name()) do
%{
group:
{2, {:default, nil},
{:message,
CucumberMessages.TestCase.TestStep.StepMatchArgumentsList.StepMatchArgument.Group}},
parameter_type_name: {1, {:default, ""}, :string}
}
end
@spec required_fields() :: []
def(required_fields()) do
[]
end
@spec unknown_fields(struct) :: [{non_neg_integer, Protox.Types.tag(), binary}]
def(unknown_fields(msg)) do
msg.__uf__()
end
@spec unknown_fields_name() :: :__uf__
def(unknown_fields_name()) do
:__uf__
end
@spec clear_unknown_fields(struct) :: struct
def(clear_unknown_fields(msg)) do
struct!(msg, [{unknown_fields_name(), []}])
end
@spec syntax() :: atom
def(syntax()) do
:proto3
end
[
@spec(
default(atom) :: {:ok, boolean | integer | String.t() | binary | float} | {:error, atom}
),
[
def(default(:parameter_type_name)) do
{:ok, ""}
end,
def(default(:group)) do
{:ok, nil}
end
],
def(default(_)) do
{:error, :no_such_field}
end
]
)
[]
end,
defmodule(CucumberMessages.TestCase) do
@moduledoc false
(
defstruct(id: "", pickle_id: "", test_steps: [], __uf__: [])
(
@spec encode(struct) :: {:ok, iodata} | {:error, any}
def(encode(msg)) do
try do
{:ok, encode!(msg)}
rescue
e ->
{:error, e}
end
end
@spec encode!(struct) :: iodata | no_return
def(encode!(msg)) do
[]
|> encode_id(msg)
|> encode_pickle_id(msg)
|> encode_test_steps(msg)
|> encode_unknown_fields(msg)
end
[]
[
defp(encode_id(acc, msg)) do
field_value = msg.id()
if(field_value == "") do
acc
else
[acc, "\n", Protox.Encode.encode_string(field_value)]
end
end,
defp(encode_pickle_id(acc, msg)) do
field_value = msg.pickle_id()
if(field_value == "") do
acc
else
[acc, <<18>>, Protox.Encode.encode_string(field_value)]
end
end,
defp(encode_test_steps(acc, msg)) do
case(msg.test_steps()) do
[] ->
acc
values ->
[
acc,
Enum.reduce(values, [], fn value, acc ->
[acc, <<26>>, Protox.Encode.encode_message(value)]
end)
]
end
end
]
defp(encode_unknown_fields(acc, msg)) do
Enum.reduce(msg.__struct__.unknown_fields(msg), acc, fn {tag, wire_type, bytes}, acc ->
case(wire_type) do
0 ->
[acc, Protox.Encode.make_key_bytes(tag, :int32), bytes]
1 ->
[acc, Protox.Encode.make_key_bytes(tag, :double), bytes]
2 ->
len_bytes = bytes |> byte_size() |> Protox.Varint.encode()
[acc, Protox.Encode.make_key_bytes(tag, :packed), len_bytes, bytes]
5 ->
[acc, Protox.Encode.make_key_bytes(tag, :float), bytes]
end
end)
end
)
(
@spec decode(binary) :: {:ok, struct} | {:error, any}
def(decode(bytes)) do
try do
{:ok, decode!(bytes)}
rescue
Protox.IllegalTagError ->
{:error, :illegal_tag}
e in Protox.RequiredFieldsError ->
{:error, {:missing_fields, e.missing_fields}}
e in Protox.DecodingError ->
{:error, {e.reason, e.binary}}
e ->
{:error, e}
end
end
(
@spec decode!(binary) :: struct | no_return
def(decode!(bytes)) do
parse_key_value(bytes, struct(CucumberMessages.TestCase))
end
)
(
@spec parse_key_value(binary, struct) :: struct
defp(parse_key_value(<<>>, msg)) do
msg
end
defp(parse_key_value(bytes, msg)) do
{field, rest} =
case(Protox.Decode.parse_key(bytes)) do
{0, _, _} ->
raise(%Protox.IllegalTagError{})
{1, _, bytes} ->
{len, bytes} = Protox.Varint.decode(bytes)
<<delimited::binary-size(len), rest::binary>> = bytes
value = delimited
field = {:id, value}
{field, rest}
{2, _, bytes} ->
{len, bytes} = Protox.Varint.decode(bytes)
<<delimited::binary-size(len), rest::binary>> = bytes
value = delimited
field = {:pickle_id, value}
{field, rest}
{3, _, bytes} ->
{len, bytes} = Protox.Varint.decode(bytes)
<<delimited::binary-size(len), rest::binary>> = bytes
value = CucumberMessages.TestCase.TestStep.decode!(delimited)
field = {:test_steps, msg.test_steps() ++ List.wrap(value)}
{field, rest}
{tag, wire_type, rest} ->
{value, new_rest} = Protox.Decode.parse_unknown(tag, wire_type, rest)
field =
{msg.__struct__.unknown_fields_name,
[value | msg.__struct__.unknown_fields(msg)]}
{field, new_rest}
end
msg_updated = struct(msg, [field])
parse_key_value(rest, msg_updated)
end
)
[]
)
@spec defs() :: %{
required(non_neg_integer) => {atom, Protox.Types.kind(), Protox.Types.type()}
}
def(defs()) do
%{
1 => {:id, {:default, ""}, :string},
2 => {:pickle_id, {:default, ""}, :string},
3 => {:test_steps, :unpacked, {:message, CucumberMessages.TestCase.TestStep}}
}
end
@spec defs_by_name() :: %{
required(atom) => {non_neg_integer, Protox.Types.kind(), Protox.Types.type()}
}
def(defs_by_name()) do
%{
id: {1, {:default, ""}, :string},
pickle_id: {2, {:default, ""}, :string},
test_steps: {3, :unpacked, {:message, CucumberMessages.TestCase.TestStep}}
}
end
@spec required_fields() :: []
def(required_fields()) do
[]
end
@spec unknown_fields(struct) :: [{non_neg_integer, Protox.Types.tag(), binary}]
def(unknown_fields(msg)) do
msg.__uf__()
end
@spec unknown_fields_name() :: :__uf__
def(unknown_fields_name()) do
:__uf__
end
@spec clear_unknown_fields(struct) :: struct
def(clear_unknown_fields(msg)) do
struct!(msg, [{unknown_fields_name(), []}])
end
@spec syntax() :: atom
def(syntax()) do
:proto3
end
[
@spec(
default(atom) :: {:ok, boolean | integer | String.t() | binary | float} | {:error, atom}
),
[
def(default(:id)) do
{:ok, ""}
end,
def(default(:pickle_id)) do
{:ok, ""}
end,
def(default(:test_steps)) do
{:error, :no_default_value}
end
],
def(default(_)) do
{:error, :no_such_field}
end
]
)
[]
end,
defmodule(CucumberMessages.GherkinDocument.Feature.Step.DataTable) do
@moduledoc false
(
defstruct(location: nil, rows: [], __uf__: [])
(
@spec encode(struct) :: {:ok, iodata} | {:error, any}
def(encode(msg)) do
try do
{:ok, encode!(msg)}
rescue
e ->
{:error, e}
end
end
@spec encode!(struct) :: iodata | no_return
def(encode!(msg)) do
[] |> encode_location(msg) |> encode_rows(msg) |> encode_unknown_fields(msg)
end
[]
[
defp(encode_location(acc, msg)) do
field_value = msg.location()
if(field_value == nil) do
acc
else
[acc, "\n", Protox.Encode.encode_message(field_value)]
end
end,
defp(encode_rows(acc, msg)) do
case(msg.rows()) do
[] ->
acc
values ->
[
acc,
Enum.reduce(values, [], fn value, acc ->
[acc, <<18>>, Protox.Encode.encode_message(value)]
end)
]
end
end
]
defp(encode_unknown_fields(acc, msg)) do
Enum.reduce(msg.__struct__.unknown_fields(msg), acc, fn {tag, wire_type, bytes}, acc ->
case(wire_type) do
0 ->
[acc, Protox.Encode.make_key_bytes(tag, :int32), bytes]
1 ->
[acc, Protox.Encode.make_key_bytes(tag, :double), bytes]
2 ->
len_bytes = bytes |> byte_size() |> Protox.Varint.encode()
[acc, Protox.Encode.make_key_bytes(tag, :packed), len_bytes, bytes]
5 ->
[acc, Protox.Encode.make_key_bytes(tag, :float), bytes]
end
end)
end
)
(
@spec decode(binary) :: {:ok, struct} | {:error, any}
def(decode(bytes)) do
try do
{:ok, decode!(bytes)}
rescue
Protox.IllegalTagError ->
{:error, :illegal_tag}
e in Protox.RequiredFieldsError ->
{:error, {:missing_fields, e.missing_fields}}
e in Protox.DecodingError ->
{:error, {e.reason, e.binary}}
e ->
{:error, e}
end
end
(
@spec decode!(binary) :: struct | no_return
def(decode!(bytes)) do
parse_key_value(
bytes,
struct(CucumberMessages.GherkinDocument.Feature.Step.DataTable)
)
end
)
(
@spec parse_key_value(binary, struct) :: struct
defp(parse_key_value(<<>>, msg)) do
msg
end
defp(parse_key_value(bytes, msg)) do
{field, rest} =
case(Protox.Decode.parse_key(bytes)) do
{0, _, _} ->
raise(%Protox.IllegalTagError{})
{1, _, bytes} ->
{len, bytes} = Protox.Varint.decode(bytes)
<<delimited::binary-size(len), rest::binary>> = bytes
value = CucumberMessages.Location.decode!(delimited)
field = {:location, Protox.Message.merge(msg.location(), value)}
{field, rest}
{2, _, bytes} ->
{len, bytes} = Protox.Varint.decode(bytes)
<<delimited::binary-size(len), rest::binary>> = bytes
value = CucumberMessages.GherkinDocument.Feature.TableRow.decode!(delimited)
field = {:rows, msg.rows() ++ List.wrap(value)}
{field, rest}
{tag, wire_type, rest} ->
{value, new_rest} = Protox.Decode.parse_unknown(tag, wire_type, rest)
field =
{msg.__struct__.unknown_fields_name,
[value | msg.__struct__.unknown_fields(msg)]}
{field, new_rest}
end
msg_updated = struct(msg, [field])
parse_key_value(rest, msg_updated)
end
)
[]
)
@spec defs() :: %{
required(non_neg_integer) => {atom, Protox.Types.kind(), Protox.Types.type()}
}
def(defs()) do
%{
1 => {:location, {:default, nil}, {:message, CucumberMessages.Location}},
2 => {:rows, :unpacked, {:message, CucumberMessages.GherkinDocument.Feature.TableRow}}
}
end
@spec defs_by_name() :: %{
required(atom) => {non_neg_integer, Protox.Types.kind(), Protox.Types.type()}
}
def(defs_by_name()) do
%{
location: {1, {:default, nil}, {:message, CucumberMessages.Location}},
rows: {2, :unpacked, {:message, CucumberMessages.GherkinDocument.Feature.TableRow}}
}
end
@spec required_fields() :: []
def(required_fields()) do
[]
end
@spec unknown_fields(struct) :: [{non_neg_integer, Protox.Types.tag(), binary}]
def(unknown_fields(msg)) do
msg.__uf__()
end
@spec unknown_fields_name() :: :__uf__
def(unknown_fields_name()) do
:__uf__
end
@spec clear_unknown_fields(struct) :: struct
def(clear_unknown_fields(msg)) do
struct!(msg, [{unknown_fields_name(), []}])
end
@spec syntax() :: atom
def(syntax()) do
:proto3
end
[
@spec(
default(atom) :: {:ok, boolean | integer | String.t() | binary | float} | {:error, atom}
),
[
def(default(:location)) do
{:ok, nil}
end,
def(default(:rows)) do
{:error, :no_default_value}
end
],
def(default(_)) do
{:error, :no_such_field}
end
]
)
[]
end,
defmodule(CucumberMessages.SourceReference) do
@moduledoc false
(
defstruct(uri: "", location: nil, __uf__: [])
(
@spec encode(struct) :: {:ok, iodata} | {:error, any}
def(encode(msg)) do
try do
{:ok, encode!(msg)}
rescue
e ->
{:error, e}
end
end
@spec encode!(struct) :: iodata | no_return
def(encode!(msg)) do
[] |> encode_uri(msg) |> encode_location(msg) |> encode_unknown_fields(msg)
end
[]
[
defp(encode_uri(acc, msg)) do
field_value = msg.uri()
if(field_value == "") do
acc
else
[acc, "\n", Protox.Encode.encode_string(field_value)]
end
end,
defp(encode_location(acc, msg)) do
field_value = msg.location()
if(field_value == nil) do
acc
else
[acc, <<18>>, Protox.Encode.encode_message(field_value)]
end
end
]
defp(encode_unknown_fields(acc, msg)) do
Enum.reduce(msg.__struct__.unknown_fields(msg), acc, fn {tag, wire_type, bytes}, acc ->
case(wire_type) do
0 ->
[acc, Protox.Encode.make_key_bytes(tag, :int32), bytes]
1 ->
[acc, Protox.Encode.make_key_bytes(tag, :double), bytes]
2 ->
len_bytes = bytes |> byte_size() |> Protox.Varint.encode()
[acc, Protox.Encode.make_key_bytes(tag, :packed), len_bytes, bytes]
5 ->
[acc, Protox.Encode.make_key_bytes(tag, :float), bytes]
end
end)
end
)
(
@spec decode(binary) :: {:ok, struct} | {:error, any}
def(decode(bytes)) do
try do
{:ok, decode!(bytes)}
rescue
Protox.IllegalTagError ->
{:error, :illegal_tag}
e in Protox.RequiredFieldsError ->
{:error, {:missing_fields, e.missing_fields}}
e in Protox.DecodingError ->
{:error, {e.reason, e.binary}}
e ->
{:error, e}
end
end
(
@spec decode!(binary) :: struct | no_return
def(decode!(bytes)) do
parse_key_value(bytes, struct(CucumberMessages.SourceReference))
end
)
(
@spec parse_key_value(binary, struct) :: struct
defp(parse_key_value(<<>>, msg)) do
msg
end
defp(parse_key_value(bytes, msg)) do
{field, rest} =
case(Protox.Decode.parse_key(bytes)) do
{0, _, _} ->
raise(%Protox.IllegalTagError{})
{1, _, bytes} ->
{len, bytes} = Protox.Varint.decode(bytes)
<<delimited::binary-size(len), rest::binary>> = bytes
value = delimited
field = {:uri, value}
{field, rest}
{2, _, bytes} ->
{len, bytes} = Protox.Varint.decode(bytes)
<<delimited::binary-size(len), rest::binary>> = bytes
value = CucumberMessages.Location.decode!(delimited)
field = {:location, Protox.Message.merge(msg.location(), value)}
{field, rest}
{tag, wire_type, rest} ->
{value, new_rest} = Protox.Decode.parse_unknown(tag, wire_type, rest)
field =
{msg.__struct__.unknown_fields_name,
[value | msg.__struct__.unknown_fields(msg)]}
{field, new_rest}
end
msg_updated = struct(msg, [field])
parse_key_value(rest, msg_updated)
end
)
[]
)
@spec defs() :: %{
required(non_neg_integer) => {atom, Protox.Types.kind(), Protox.Types.type()}
}
def(defs()) do
%{
1 => {:uri, {:default, ""}, :string},
2 => {:location, {:default, nil}, {:message, CucumberMessages.Location}}
}
end
@spec defs_by_name() :: %{
required(atom) => {non_neg_integer, Protox.Types.kind(), Protox.Types.type()}
}
def(defs_by_name()) do
%{
location: {2, {:default, nil}, {:message, CucumberMessages.Location}},
uri: {1, {:default, ""}, :string}
}
end
@spec required_fields() :: []
def(required_fields()) do
[]
end
@spec unknown_fields(struct) :: [{non_neg_integer, Protox.Types.tag(), binary}]
def(unknown_fields(msg)) do
msg.__uf__()
end
@spec unknown_fields_name() :: :__uf__
def(unknown_fields_name()) do
:__uf__
end
@spec clear_unknown_fields(struct) :: struct
def(clear_unknown_fields(msg)) do
struct!(msg, [{unknown_fields_name(), []}])
end
@spec syntax() :: atom
def(syntax()) do
:proto3
end
[
@spec(
default(atom) :: {:ok, boolean | integer | String.t() | binary | float} | {:error, atom}
),
[
def(default(:uri)) do
{:ok, ""}
end,
def(default(:location)) do
{:ok, nil}
end
],
def(default(_)) do
{:error, :no_such_field}
end
]
)
[]
end,
defmodule(CucumberMessages.GherkinDocument.Feature.Step) do
@moduledoc false
(
defstruct(location: nil, keyword: "", text: "", argument: nil, id: "", __uf__: [])
(
@spec encode(struct) :: {:ok, iodata} | {:error, any}
def(encode(msg)) do
try do
{:ok, encode!(msg)}
rescue
e ->
{:error, e}
end
end
@spec encode!(struct) :: iodata | no_return
def(encode!(msg)) do
[]
|> encode_argument(msg)
|> encode_location(msg)
|> encode_keyword(msg)
|> encode_text(msg)
|> encode_id(msg)
|> encode_unknown_fields(msg)
end
[
defp(encode_argument(acc, msg)) do
case(msg.argument()) do
nil ->
acc
{:doc_string, _field_value} ->
encode_doc_string(acc, msg)
{:data_table, _field_value} ->
encode_data_table(acc, msg)
end
end
]
[
defp(encode_location(acc, msg)) do
field_value = msg.location()
if(field_value == nil) do
acc
else
[acc, "\n", Protox.Encode.encode_message(field_value)]
end
end,
defp(encode_keyword(acc, msg)) do
field_value = msg.keyword()
if(field_value == "") do
acc
else
[acc, <<18>>, Protox.Encode.encode_string(field_value)]
end
end,
defp(encode_text(acc, msg)) do
field_value = msg.text()
if(field_value == "") do
acc
else
[acc, <<26>>, Protox.Encode.encode_string(field_value)]
end
end,
defp(encode_doc_string(acc, msg)) do
{_, field_value} = msg.argument()
[acc, "\"", Protox.Encode.encode_message(field_value)]
end,
defp(encode_data_table(acc, msg)) do
{_, field_value} = msg.argument()
[acc, "*", Protox.Encode.encode_message(field_value)]
end,
defp(encode_id(acc, msg)) do
field_value = msg.id()
if(field_value == "") do
acc
else
[acc, "2", Protox.Encode.encode_string(field_value)]
end
end
]
defp(encode_unknown_fields(acc, msg)) do
Enum.reduce(msg.__struct__.unknown_fields(msg), acc, fn {tag, wire_type, bytes}, acc ->
case(wire_type) do
0 ->
[acc, Protox.Encode.make_key_bytes(tag, :int32), bytes]
1 ->
[acc, Protox.Encode.make_key_bytes(tag, :double), bytes]
2 ->
len_bytes = bytes |> byte_size() |> Protox.Varint.encode()
[acc, Protox.Encode.make_key_bytes(tag, :packed), len_bytes, bytes]
5 ->
[acc, Protox.Encode.make_key_bytes(tag, :float), bytes]
end
end)
end
)
(
@spec decode(binary) :: {:ok, struct} | {:error, any}
def(decode(bytes)) do
try do
{:ok, decode!(bytes)}
rescue
Protox.IllegalTagError ->
{:error, :illegal_tag}
e in Protox.RequiredFieldsError ->
{:error, {:missing_fields, e.missing_fields}}
e in Protox.DecodingError ->
{:error, {e.reason, e.binary}}
e ->
{:error, e}
end
end
(
@spec decode!(binary) :: struct | no_return
def(decode!(bytes)) do
parse_key_value(bytes, struct(CucumberMessages.GherkinDocument.Feature.Step))
end
)
(
@spec parse_key_value(binary, struct) :: struct
defp(parse_key_value(<<>>, msg)) do
msg
end
defp(parse_key_value(bytes, msg)) do
{field, rest} =
case(Protox.Decode.parse_key(bytes)) do
{0, _, _} ->
raise(%Protox.IllegalTagError{})
{1, _, bytes} ->
{len, bytes} = Protox.Varint.decode(bytes)
<<delimited::binary-size(len), rest::binary>> = bytes
value = CucumberMessages.Location.decode!(delimited)
field = {:location, Protox.Message.merge(msg.location(), value)}
{field, rest}
{2, _, bytes} ->
{len, bytes} = Protox.Varint.decode(bytes)
<<delimited::binary-size(len), rest::binary>> = bytes
value = delimited
field = {:keyword, value}
{field, rest}
{3, _, bytes} ->
{len, bytes} = Protox.Varint.decode(bytes)
<<delimited::binary-size(len), rest::binary>> = bytes
value = delimited
field = {:text, value}
{field, rest}
{4, _, bytes} ->
{len, bytes} = Protox.Varint.decode(bytes)
<<delimited::binary-size(len), rest::binary>> = bytes
value =
CucumberMessages.GherkinDocument.Feature.Step.DocString.decode!(delimited)
field =
case(msg.argument()) do
{:doc_string, previous_value} ->
{:argument, {:doc_string, Protox.Message.merge(previous_value, value)}}
_ ->
{:argument, {:doc_string, value}}
end
{field, rest}
{5, _, bytes} ->
{len, bytes} = Protox.Varint.decode(bytes)
<<delimited::binary-size(len), rest::binary>> = bytes
value =
CucumberMessages.GherkinDocument.Feature.Step.DataTable.decode!(delimited)
field =
case(msg.argument()) do
{:data_table, previous_value} ->
{:argument, {:data_table, Protox.Message.merge(previous_value, value)}}
_ ->
{:argument, {:data_table, value}}
end
{field, rest}
{6, _, bytes} ->
{len, bytes} = Protox.Varint.decode(bytes)
<<delimited::binary-size(len), rest::binary>> = bytes
value = delimited
field = {:id, value}
{field, rest}
{tag, wire_type, rest} ->
{value, new_rest} = Protox.Decode.parse_unknown(tag, wire_type, rest)
field =
{msg.__struct__.unknown_fields_name,
[value | msg.__struct__.unknown_fields(msg)]}
{field, new_rest}
end
msg_updated = struct(msg, [field])
parse_key_value(rest, msg_updated)
end
)
[]
)
@spec defs() :: %{
required(non_neg_integer) => {atom, Protox.Types.kind(), Protox.Types.type()}
}
def(defs()) do
%{
1 => {:location, {:default, nil}, {:message, CucumberMessages.Location}},
2 => {:keyword, {:default, ""}, :string},
3 => {:text, {:default, ""}, :string},
4 =>
{:doc_string, {:oneof, :argument},
{:message, CucumberMessages.GherkinDocument.Feature.Step.DocString}},
5 =>
{:data_table, {:oneof, :argument},
{:message, CucumberMessages.GherkinDocument.Feature.Step.DataTable}},
6 => {:id, {:default, ""}, :string}
}
end
@spec defs_by_name() :: %{
required(atom) => {non_neg_integer, Protox.Types.kind(), Protox.Types.type()}
}
def(defs_by_name()) do
%{
data_table:
{5, {:oneof, :argument},
{:message, CucumberMessages.GherkinDocument.Feature.Step.DataTable}},
doc_string:
{4, {:oneof, :argument},
{:message, CucumberMessages.GherkinDocument.Feature.Step.DocString}},
id: {6, {:default, ""}, :string},
keyword: {2, {:default, ""}, :string},
location: {1, {:default, nil}, {:message, CucumberMessages.Location}},
text: {3, {:default, ""}, :string}
}
end
@spec required_fields() :: []
def(required_fields()) do
[]
end
@spec unknown_fields(struct) :: [{non_neg_integer, Protox.Types.tag(), binary}]
def(unknown_fields(msg)) do
msg.__uf__()
end
@spec unknown_fields_name() :: :__uf__
def(unknown_fields_name()) do
:__uf__
end
@spec clear_unknown_fields(struct) :: struct
def(clear_unknown_fields(msg)) do
struct!(msg, [{unknown_fields_name(), []}])
end
@spec syntax() :: atom
def(syntax()) do
:proto3
end
[
@spec(
default(atom) :: {:ok, boolean | integer | String.t() | binary | float} | {:error, atom}
),
[
def(default(:location)) do
{:ok, nil}
end,
def(default(:keyword)) do
{:ok, ""}
end,
def(default(:text)) do
{:ok, ""}
end,
def(default(:doc_string)) do
{:error, :no_default_value}
end,
def(default(:data_table)) do
{:error, :no_default_value}
end,
def(default(:id)) do
{:ok, ""}
end
],
def(default(_)) do
{:error, :no_such_field}
end
]
)
[]
end,
defmodule(CucumberMessages.TestCaseStarted) do
@moduledoc false
(
defstruct(timestamp: nil, attempt: 0, test_case_id: "", id: "", __uf__: [])
(
@spec encode(struct) :: {:ok, iodata} | {:error, any}
def(encode(msg)) do
try do
{:ok, encode!(msg)}
rescue
e ->
{:error, e}
end
end
@spec encode!(struct) :: iodata | no_return
def(encode!(msg)) do
[]
|> encode_timestamp(msg)
|> encode_attempt(msg)
|> encode_test_case_id(msg)
|> encode_id(msg)
|> encode_unknown_fields(msg)
end
[]
[
defp(encode_timestamp(acc, msg)) do
field_value = msg.timestamp()
if(field_value == nil) do
acc
else
[acc, "\n", Protox.Encode.encode_message(field_value)]
end
end,
defp(encode_attempt(acc, msg)) do
field_value = msg.attempt()
if(field_value == 0) do
acc
else
[acc, <<24>>, Protox.Encode.encode_uint32(field_value)]
end
end,
defp(encode_test_case_id(acc, msg)) do
field_value = msg.test_case_id()
if(field_value == "") do
acc
else
[acc, "\"", Protox.Encode.encode_string(field_value)]
end
end,
defp(encode_id(acc, msg)) do
field_value = msg.id()
if(field_value == "") do
acc
else
[acc, "*", Protox.Encode.encode_string(field_value)]
end
end
]
defp(encode_unknown_fields(acc, msg)) do
Enum.reduce(msg.__struct__.unknown_fields(msg), acc, fn {tag, wire_type, bytes}, acc ->
case(wire_type) do
0 ->
[acc, Protox.Encode.make_key_bytes(tag, :int32), bytes]
1 ->
[acc, Protox.Encode.make_key_bytes(tag, :double), bytes]
2 ->
len_bytes = bytes |> byte_size() |> Protox.Varint.encode()
[acc, Protox.Encode.make_key_bytes(tag, :packed), len_bytes, bytes]
5 ->
[acc, Protox.Encode.make_key_bytes(tag, :float), bytes]
end
end)
end
)
(
@spec decode(binary) :: {:ok, struct} | {:error, any}
def(decode(bytes)) do
try do
{:ok, decode!(bytes)}
rescue
Protox.IllegalTagError ->
{:error, :illegal_tag}
e in Protox.RequiredFieldsError ->
{:error, {:missing_fields, e.missing_fields}}
e in Protox.DecodingError ->
{:error, {e.reason, e.binary}}
e ->
{:error, e}
end
end
(
@spec decode!(binary) :: struct | no_return
def(decode!(bytes)) do
parse_key_value(bytes, struct(CucumberMessages.TestCaseStarted))
end
)
(
@spec parse_key_value(binary, struct) :: struct
defp(parse_key_value(<<>>, msg)) do
msg
end
defp(parse_key_value(bytes, msg)) do
{field, rest} =
case(Protox.Decode.parse_key(bytes)) do
{0, _, _} ->
raise(%Protox.IllegalTagError{})
{1, _, bytes} ->
{len, bytes} = Protox.Varint.decode(bytes)
<<delimited::binary-size(len), rest::binary>> = bytes
value = CucumberMessages.Timestamp.decode!(delimited)
field = {:timestamp, Protox.Message.merge(msg.timestamp(), value)}
{field, rest}
{3, _, bytes} ->
{value, rest} = Protox.Decode.parse_uint32(bytes)
field = {:attempt, value}
{field, rest}
{4, _, bytes} ->
{len, bytes} = Protox.Varint.decode(bytes)
<<delimited::binary-size(len), rest::binary>> = bytes
value = delimited
field = {:test_case_id, value}
{field, rest}
{5, _, bytes} ->
{len, bytes} = Protox.Varint.decode(bytes)
<<delimited::binary-size(len), rest::binary>> = bytes
value = delimited
field = {:id, value}
{field, rest}
{tag, wire_type, rest} ->
{value, new_rest} = Protox.Decode.parse_unknown(tag, wire_type, rest)
field =
{msg.__struct__.unknown_fields_name,
[value | msg.__struct__.unknown_fields(msg)]}
{field, new_rest}
end
msg_updated = struct(msg, [field])
parse_key_value(rest, msg_updated)
end
)
[]
)
@spec defs() :: %{
required(non_neg_integer) => {atom, Protox.Types.kind(), Protox.Types.type()}
}
def(defs()) do
%{
1 => {:timestamp, {:default, nil}, {:message, CucumberMessages.Timestamp}},
3 => {:attempt, {:default, 0}, :uint32},
4 => {:test_case_id, {:default, ""}, :string},
5 => {:id, {:default, ""}, :string}
}
end
@spec defs_by_name() :: %{
required(atom) => {non_neg_integer, Protox.Types.kind(), Protox.Types.type()}
}
def(defs_by_name()) do
%{
attempt: {3, {:default, 0}, :uint32},
id: {5, {:default, ""}, :string},
test_case_id: {4, {:default, ""}, :string},
timestamp: {1, {:default, nil}, {:message, CucumberMessages.Timestamp}}
}
end
@spec required_fields() :: []
def(required_fields()) do
[]
end
@spec unknown_fields(struct) :: [{non_neg_integer, Protox.Types.tag(), binary}]
def(unknown_fields(msg)) do
msg.__uf__()
end
@spec unknown_fields_name() :: :__uf__
def(unknown_fields_name()) do
:__uf__
end
@spec clear_unknown_fields(struct) :: struct
def(clear_unknown_fields(msg)) do
struct!(msg, [{unknown_fields_name(), []}])
end
@spec syntax() :: atom
def(syntax()) do
:proto3
end
[
@spec(
default(atom) :: {:ok, boolean | integer | String.t() | binary | float} | {:error, atom}
),
[
def(default(:timestamp)) do
{:ok, nil}
end,
def(default(:attempt)) do
{:ok, 0}
end,
def(default(:test_case_id)) do
{:ok, ""}
end,
def(default(:id)) do
{:ok, ""}
end
],
def(default(_)) do
{:error, :no_such_field}
end
]
)
[]
end,
defmodule(CucumberMessages.TestStepFinished.TestStepResult) do
@moduledoc false
(
defstruct(status: :UNKNOWN, message: "", duration: nil, will_be_retried: false, __uf__: [])
(
@spec encode(struct) :: {:ok, iodata} | {:error, any}
def(encode(msg)) do
try do
{:ok, encode!(msg)}
rescue
e ->
{:error, e}
end
end
@spec encode!(struct) :: iodata | no_return
def(encode!(msg)) do
[]
|> encode_status(msg)
|> encode_message(msg)
|> encode_duration(msg)
|> encode_will_be_retried(msg)
|> encode_unknown_fields(msg)
end
[]
[
defp(encode_status(acc, msg)) do
field_value = msg.status()
if(field_value == :UNKNOWN) do
acc
else
[
acc,
"\b",
field_value
|> CucumberMessages.TestStepFinished.TestStepResult.Status.encode()
|> Protox.Encode.encode_enum()
]
end
end,
defp(encode_message(acc, msg)) do
field_value = msg.message()
if(field_value == "") do
acc
else
[acc, <<18>>, Protox.Encode.encode_string(field_value)]
end
end,
defp(encode_duration(acc, msg)) do
field_value = msg.duration()
if(field_value == nil) do
acc
else
[acc, <<26>>, Protox.Encode.encode_message(field_value)]
end
end,
defp(encode_will_be_retried(acc, msg)) do
field_value = msg.will_be_retried()
if(field_value == false) do
acc
else
[acc, " ", Protox.Encode.encode_bool(field_value)]
end
end
]
defp(encode_unknown_fields(acc, msg)) do
Enum.reduce(msg.__struct__.unknown_fields(msg), acc, fn {tag, wire_type, bytes}, acc ->
case(wire_type) do
0 ->
[acc, Protox.Encode.make_key_bytes(tag, :int32), bytes]
1 ->
[acc, Protox.Encode.make_key_bytes(tag, :double), bytes]
2 ->
len_bytes = bytes |> byte_size() |> Protox.Varint.encode()
[acc, Protox.Encode.make_key_bytes(tag, :packed), len_bytes, bytes]
5 ->
[acc, Protox.Encode.make_key_bytes(tag, :float), bytes]
end
end)
end
)
(
@spec decode(binary) :: {:ok, struct} | {:error, any}
def(decode(bytes)) do
try do
{:ok, decode!(bytes)}
rescue
Protox.IllegalTagError ->
{:error, :illegal_tag}
e in Protox.RequiredFieldsError ->
{:error, {:missing_fields, e.missing_fields}}
e in Protox.DecodingError ->
{:error, {e.reason, e.binary}}
e ->
{:error, e}
end
end
(
@spec decode!(binary) :: struct | no_return
def(decode!(bytes)) do
parse_key_value(bytes, struct(CucumberMessages.TestStepFinished.TestStepResult))
end
)
(
@spec parse_key_value(binary, struct) :: struct
defp(parse_key_value(<<>>, msg)) do
msg
end
defp(parse_key_value(bytes, msg)) do
{field, rest} =
case(Protox.Decode.parse_key(bytes)) do
{0, _, _} ->
raise(%Protox.IllegalTagError{})
{1, _, bytes} ->
{value, rest} =
Protox.Decode.parse_enum(
bytes,
CucumberMessages.TestStepFinished.TestStepResult.Status
)
field = {:status, value}
{field, rest}
{2, _, bytes} ->
{len, bytes} = Protox.Varint.decode(bytes)
<<delimited::binary-size(len), rest::binary>> = bytes
value = delimited
field = {:message, value}
{field, rest}
{3, _, bytes} ->
{len, bytes} = Protox.Varint.decode(bytes)
<<delimited::binary-size(len), rest::binary>> = bytes
value = CucumberMessages.Duration.decode!(delimited)
field = {:duration, Protox.Message.merge(msg.duration(), value)}
{field, rest}
{4, _, bytes} ->
{value, rest} = Protox.Decode.parse_bool(bytes)
field = {:will_be_retried, value}
{field, rest}
{tag, wire_type, rest} ->
{value, new_rest} = Protox.Decode.parse_unknown(tag, wire_type, rest)
field =
{msg.__struct__.unknown_fields_name,
[value | msg.__struct__.unknown_fields(msg)]}
{field, new_rest}
end
msg_updated = struct(msg, [field])
parse_key_value(rest, msg_updated)
end
)
[]
)
@spec defs() :: %{
required(non_neg_integer) => {atom, Protox.Types.kind(), Protox.Types.type()}
}
def(defs()) do
%{
1 =>
{:status, {:default, :UNKNOWN},
{:enum, CucumberMessages.TestStepFinished.TestStepResult.Status}},
2 => {:message, {:default, ""}, :string},
3 => {:duration, {:default, nil}, {:message, CucumberMessages.Duration}},
4 => {:will_be_retried, {:default, false}, :bool}
}
end
@spec defs_by_name() :: %{
required(atom) => {non_neg_integer, Protox.Types.kind(), Protox.Types.type()}
}
def(defs_by_name()) do
%{
duration: {3, {:default, nil}, {:message, CucumberMessages.Duration}},
message: {2, {:default, ""}, :string},
status:
{1, {:default, :UNKNOWN},
{:enum, CucumberMessages.TestStepFinished.TestStepResult.Status}},
will_be_retried: {4, {:default, false}, :bool}
}
end
@spec required_fields() :: []
def(required_fields()) do
[]
end
@spec unknown_fields(struct) :: [{non_neg_integer, Protox.Types.tag(), binary}]
def(unknown_fields(msg)) do
msg.__uf__()
end
@spec unknown_fields_name() :: :__uf__
def(unknown_fields_name()) do
:__uf__
end
@spec clear_unknown_fields(struct) :: struct
def(clear_unknown_fields(msg)) do
struct!(msg, [{unknown_fields_name(), []}])
end
@spec syntax() :: atom
def(syntax()) do
:proto3
end
[
@spec(
default(atom) :: {:ok, boolean | integer | String.t() | binary | float} | {:error, atom}
),
[
def(default(:status)) do
{:ok, :UNKNOWN}
end,
def(default(:message)) do
{:ok, ""}
end,
def(default(:duration)) do
{:ok, nil}
end,
def(default(:will_be_retried)) do
{:ok, false}
end
],
def(default(_)) do
{:error, :no_such_field}
end
]
)
[]
end,
defmodule(CucumberMessages.Envelope) do
@moduledoc false
(
defstruct(message: nil, __uf__: [])
(
@spec encode(struct) :: {:ok, iodata} | {:error, any}
def(encode(msg)) do
try do
{:ok, encode!(msg)}
rescue
e ->
{:error, e}
end
end
@spec encode!(struct) :: iodata | no_return
def(encode!(msg)) do
[] |> encode_message(msg) |> encode_unknown_fields(msg)
end
[
defp(encode_message(acc, msg)) do
case(msg.message()) do
nil ->
acc
{:source, _field_value} ->
encode_source(acc, msg)
{:gherkin_document, _field_value} ->
encode_gherkin_document(acc, msg)
{:pickle, _field_value} ->
encode_pickle(acc, msg)
{:step_definition, _field_value} ->
encode_step_definition(acc, msg)
{:hook, _field_value} ->
encode_hook(acc, msg)
{:parameter_type, _field_value} ->
encode_parameter_type(acc, msg)
{:test_case, _field_value} ->
encode_test_case(acc, msg)
{:undefined_parameter_type, _field_value} ->
encode_undefined_parameter_type(acc, msg)
{:test_run_started, _field_value} ->
encode_test_run_started(acc, msg)
{:test_case_started, _field_value} ->
encode_test_case_started(acc, msg)
{:test_step_started, _field_value} ->
encode_test_step_started(acc, msg)
{:attachment, _field_value} ->
encode_attachment(acc, msg)
{:test_step_finished, _field_value} ->
encode_test_step_finished(acc, msg)
{:test_case_finished, _field_value} ->
encode_test_case_finished(acc, msg)
{:test_run_finished, _field_value} ->
encode_test_run_finished(acc, msg)
{:parse_error, _field_value} ->
encode_parse_error(acc, msg)
{:meta, _field_value} ->
encode_meta(acc, msg)
end
end
]
[
defp(encode_source(acc, msg)) do
{_, field_value} = msg.message()
[acc, "\n", Protox.Encode.encode_message(field_value)]
end,
defp(encode_gherkin_document(acc, msg)) do
{_, field_value} = msg.message()
[acc, <<18>>, Protox.Encode.encode_message(field_value)]
end,
defp(encode_pickle(acc, msg)) do
{_, field_value} = msg.message()
[acc, <<26>>, Protox.Encode.encode_message(field_value)]
end,
defp(encode_step_definition(acc, msg)) do
{_, field_value} = msg.message()
[acc, "\"", Protox.Encode.encode_message(field_value)]
end,
defp(encode_hook(acc, msg)) do
{_, field_value} = msg.message()
[acc, "*", Protox.Encode.encode_message(field_value)]
end,
defp(encode_parameter_type(acc, msg)) do
{_, field_value} = msg.message()
[acc, "2", Protox.Encode.encode_message(field_value)]
end,
defp(encode_test_case(acc, msg)) do
{_, field_value} = msg.message()
[acc, ":", Protox.Encode.encode_message(field_value)]
end,
defp(encode_undefined_parameter_type(acc, msg)) do
{_, field_value} = msg.message()
[acc, "B", Protox.Encode.encode_message(field_value)]
end,
defp(encode_test_run_started(acc, msg)) do
{_, field_value} = msg.message()
[acc, "J", Protox.Encode.encode_message(field_value)]
end,
defp(encode_test_case_started(acc, msg)) do
{_, field_value} = msg.message()
[acc, "R", Protox.Encode.encode_message(field_value)]
end,
defp(encode_test_step_started(acc, msg)) do
{_, field_value} = msg.message()
[acc, "Z", Protox.Encode.encode_message(field_value)]
end,
defp(encode_attachment(acc, msg)) do
{_, field_value} = msg.message()
[acc, "b", Protox.Encode.encode_message(field_value)]
end,
defp(encode_test_step_finished(acc, msg)) do
{_, field_value} = msg.message()
[acc, "j", Protox.Encode.encode_message(field_value)]
end,
defp(encode_test_case_finished(acc, msg)) do
{_, field_value} = msg.message()
[acc, "r", Protox.Encode.encode_message(field_value)]
end,
defp(encode_test_run_finished(acc, msg)) do
{_, field_value} = msg.message()
[acc, "z", Protox.Encode.encode_message(field_value)]
end,
defp(encode_parse_error(acc, msg)) do
{_, field_value} = msg.message()
[acc, [<<130>>, <<1>>], Protox.Encode.encode_message(field_value)]
end,
defp(encode_meta(acc, msg)) do
{_, field_value} = msg.message()
[acc, [<<138>>, <<1>>], Protox.Encode.encode_message(field_value)]
end
]
defp(encode_unknown_fields(acc, msg)) do
Enum.reduce(msg.__struct__.unknown_fields(msg), acc, fn {tag, wire_type, bytes}, acc ->
case(wire_type) do
0 ->
[acc, Protox.Encode.make_key_bytes(tag, :int32), bytes]
1 ->
[acc, Protox.Encode.make_key_bytes(tag, :double), bytes]
2 ->
len_bytes = bytes |> byte_size() |> Protox.Varint.encode()
[acc, Protox.Encode.make_key_bytes(tag, :packed), len_bytes, bytes]
5 ->
[acc, Protox.Encode.make_key_bytes(tag, :float), bytes]
end
end)
end
)
(
@spec decode(binary) :: {:ok, struct} | {:error, any}
def(decode(bytes)) do
try do
{:ok, decode!(bytes)}
rescue
Protox.IllegalTagError ->
{:error, :illegal_tag}
e in Protox.RequiredFieldsError ->
{:error, {:missing_fields, e.missing_fields}}
e in Protox.DecodingError ->
{:error, {e.reason, e.binary}}
e ->
{:error, e}
end
end
(
@spec decode!(binary) :: struct | no_return
def(decode!(bytes)) do
parse_key_value(bytes, struct(CucumberMessages.Envelope))
end
)
(
@spec parse_key_value(binary, struct) :: struct
defp(parse_key_value(<<>>, msg)) do
msg
end
defp(parse_key_value(bytes, msg)) do
{field, rest} =
case(Protox.Decode.parse_key(bytes)) do
{0, _, _} ->
raise(%Protox.IllegalTagError{})
{1, _, bytes} ->
{len, bytes} = Protox.Varint.decode(bytes)
<<delimited::binary-size(len), rest::binary>> = bytes
value = CucumberMessages.Source.decode!(delimited)
field =
case(msg.message()) do
{:source, previous_value} ->
{:message, {:source, Protox.Message.merge(previous_value, value)}}
_ ->
{:message, {:source, value}}
end
{field, rest}
{2, _, bytes} ->
{len, bytes} = Protox.Varint.decode(bytes)
<<delimited::binary-size(len), rest::binary>> = bytes
value = CucumberMessages.GherkinDocument.decode!(delimited)
field =
case(msg.message()) do
{:gherkin_document, previous_value} ->
{:message,
{:gherkin_document, Protox.Message.merge(previous_value, value)}}
_ ->
{:message, {:gherkin_document, value}}
end
{field, rest}
{3, _, bytes} ->
{len, bytes} = Protox.Varint.decode(bytes)
<<delimited::binary-size(len), rest::binary>> = bytes
value = CucumberMessages.Pickle.decode!(delimited)
field =
case(msg.message()) do
{:pickle, previous_value} ->
{:message, {:pickle, Protox.Message.merge(previous_value, value)}}
_ ->
{:message, {:pickle, value}}
end
{field, rest}
{4, _, bytes} ->
{len, bytes} = Protox.Varint.decode(bytes)
<<delimited::binary-size(len), rest::binary>> = bytes
value = CucumberMessages.StepDefinition.decode!(delimited)
field =
case(msg.message()) do
{:step_definition, previous_value} ->
{:message,
{:step_definition, Protox.Message.merge(previous_value, value)}}
_ ->
{:message, {:step_definition, value}}
end
{field, rest}
{5, _, bytes} ->
{len, bytes} = Protox.Varint.decode(bytes)
<<delimited::binary-size(len), rest::binary>> = bytes
value = CucumberMessages.Hook.decode!(delimited)
field =
case(msg.message()) do
{:hook, previous_value} ->
{:message, {:hook, Protox.Message.merge(previous_value, value)}}
_ ->
{:message, {:hook, value}}
end
{field, rest}
{6, _, bytes} ->
{len, bytes} = Protox.Varint.decode(bytes)
<<delimited::binary-size(len), rest::binary>> = bytes
value = CucumberMessages.ParameterType.decode!(delimited)
field =
case(msg.message()) do
{:parameter_type, previous_value} ->
{:message, {:parameter_type, Protox.Message.merge(previous_value, value)}}
_ ->
{:message, {:parameter_type, value}}
end
{field, rest}
{7, _, bytes} ->
{len, bytes} = Protox.Varint.decode(bytes)
<<delimited::binary-size(len), rest::binary>> = bytes
value = CucumberMessages.TestCase.decode!(delimited)
field =
case(msg.message()) do
{:test_case, previous_value} ->
{:message, {:test_case, Protox.Message.merge(previous_value, value)}}
_ ->
{:message, {:test_case, value}}
end
{field, rest}
{8, _, bytes} ->
{len, bytes} = Protox.Varint.decode(bytes)
<<delimited::binary-size(len), rest::binary>> = bytes
value = CucumberMessages.UndefinedParameterType.decode!(delimited)
field =
case(msg.message()) do
{:undefined_parameter_type, previous_value} ->
{:message,
{:undefined_parameter_type, Protox.Message.merge(previous_value, value)}}
_ ->
{:message, {:undefined_parameter_type, value}}
end
{field, rest}
{9, _, bytes} ->
{len, bytes} = Protox.Varint.decode(bytes)
<<delimited::binary-size(len), rest::binary>> = bytes
value = CucumberMessages.TestRunStarted.decode!(delimited)
field =
case(msg.message()) do
{:test_run_started, previous_value} ->
{:message,
{:test_run_started, Protox.Message.merge(previous_value, value)}}
_ ->
{:message, {:test_run_started, value}}
end
{field, rest}
{10, _, bytes} ->
{len, bytes} = Protox.Varint.decode(bytes)
<<delimited::binary-size(len), rest::binary>> = bytes
value = CucumberMessages.TestCaseStarted.decode!(delimited)
field =
case(msg.message()) do
{:test_case_started, previous_value} ->
{:message,
{:test_case_started, Protox.Message.merge(previous_value, value)}}
_ ->
{:message, {:test_case_started, value}}
end
{field, rest}
{11, _, bytes} ->
{len, bytes} = Protox.Varint.decode(bytes)
<<delimited::binary-size(len), rest::binary>> = bytes
value = CucumberMessages.TestStepStarted.decode!(delimited)
field =
case(msg.message()) do
{:test_step_started, previous_value} ->
{:message,
{:test_step_started, Protox.Message.merge(previous_value, value)}}
_ ->
{:message, {:test_step_started, value}}
end
{field, rest}
{12, _, bytes} ->
{len, bytes} = Protox.Varint.decode(bytes)
<<delimited::binary-size(len), rest::binary>> = bytes
value = CucumberMessages.Attachment.decode!(delimited)
field =
case(msg.message()) do
{:attachment, previous_value} ->
{:message, {:attachment, Protox.Message.merge(previous_value, value)}}
_ ->
{:message, {:attachment, value}}
end
{field, rest}
{13, _, bytes} ->
{len, bytes} = Protox.Varint.decode(bytes)
<<delimited::binary-size(len), rest::binary>> = bytes
value = CucumberMessages.TestStepFinished.decode!(delimited)
field =
case(msg.message()) do
{:test_step_finished, previous_value} ->
{:message,
{:test_step_finished, Protox.Message.merge(previous_value, value)}}
_ ->
{:message, {:test_step_finished, value}}
end
{field, rest}
{14, _, bytes} ->
{len, bytes} = Protox.Varint.decode(bytes)
<<delimited::binary-size(len), rest::binary>> = bytes
value = CucumberMessages.TestCaseFinished.decode!(delimited)
field =
case(msg.message()) do
{:test_case_finished, previous_value} ->
{:message,
{:test_case_finished, Protox.Message.merge(previous_value, value)}}
_ ->
{:message, {:test_case_finished, value}}
end
{field, rest}
{15, _, bytes} ->
{len, bytes} = Protox.Varint.decode(bytes)
<<delimited::binary-size(len), rest::binary>> = bytes
value = CucumberMessages.TestRunFinished.decode!(delimited)
field =
case(msg.message()) do
{:test_run_finished, previous_value} ->
{:message,
{:test_run_finished, Protox.Message.merge(previous_value, value)}}
_ ->
{:message, {:test_run_finished, value}}
end
{field, rest}
{16, _, bytes} ->
{len, bytes} = Protox.Varint.decode(bytes)
<<delimited::binary-size(len), rest::binary>> = bytes
value = CucumberMessages.ParseError.decode!(delimited)
field =
case(msg.message()) do
{:parse_error, previous_value} ->
{:message, {:parse_error, Protox.Message.merge(previous_value, value)}}
_ ->
{:message, {:parse_error, value}}
end
{field, rest}
{17, _, bytes} ->
{len, bytes} = Protox.Varint.decode(bytes)
<<delimited::binary-size(len), rest::binary>> = bytes
value = CucumberMessages.Meta.decode!(delimited)
field =
case(msg.message()) do
{:meta, previous_value} ->
{:message, {:meta, Protox.Message.merge(previous_value, value)}}
_ ->
{:message, {:meta, value}}
end
{field, rest}
{tag, wire_type, rest} ->
{value, new_rest} = Protox.Decode.parse_unknown(tag, wire_type, rest)
field =
{msg.__struct__.unknown_fields_name,
[value | msg.__struct__.unknown_fields(msg)]}
{field, new_rest}
end
msg_updated = struct(msg, [field])
parse_key_value(rest, msg_updated)
end
)
[]
)
@spec defs() :: %{
required(non_neg_integer) => {atom, Protox.Types.kind(), Protox.Types.type()}
}
def(defs()) do
%{
1 => {:source, {:oneof, :message}, {:message, CucumberMessages.Source}},
2 =>
{:gherkin_document, {:oneof, :message}, {:message, CucumberMessages.GherkinDocument}},
3 => {:pickle, {:oneof, :message}, {:message, CucumberMessages.Pickle}},
4 =>
{:step_definition, {:oneof, :message}, {:message, CucumberMessages.StepDefinition}},
5 => {:hook, {:oneof, :message}, {:message, CucumberMessages.Hook}},
6 => {:parameter_type, {:oneof, :message}, {:message, CucumberMessages.ParameterType}},
7 => {:test_case, {:oneof, :message}, {:message, CucumberMessages.TestCase}},
8 =>
{:undefined_parameter_type, {:oneof, :message},
{:message, CucumberMessages.UndefinedParameterType}},
9 =>
{:test_run_started, {:oneof, :message}, {:message, CucumberMessages.TestRunStarted}},
10 =>
{:test_case_started, {:oneof, :message}, {:message, CucumberMessages.TestCaseStarted}},
11 =>
{:test_step_started, {:oneof, :message}, {:message, CucumberMessages.TestStepStarted}},
12 => {:attachment, {:oneof, :message}, {:message, CucumberMessages.Attachment}},
13 =>
{:test_step_finished, {:oneof, :message},
{:message, CucumberMessages.TestStepFinished}},
14 =>
{:test_case_finished, {:oneof, :message},
{:message, CucumberMessages.TestCaseFinished}},
15 =>
{:test_run_finished, {:oneof, :message}, {:message, CucumberMessages.TestRunFinished}},
16 => {:parse_error, {:oneof, :message}, {:message, CucumberMessages.ParseError}},
17 => {:meta, {:oneof, :message}, {:message, CucumberMessages.Meta}}
}
end
@spec defs_by_name() :: %{
required(atom) => {non_neg_integer, Protox.Types.kind(), Protox.Types.type()}
}
def(defs_by_name()) do
%{
attachment: {12, {:oneof, :message}, {:message, CucumberMessages.Attachment}},
gherkin_document: {2, {:oneof, :message}, {:message, CucumberMessages.GherkinDocument}},
hook: {5, {:oneof, :message}, {:message, CucumberMessages.Hook}},
meta: {17, {:oneof, :message}, {:message, CucumberMessages.Meta}},
parameter_type: {6, {:oneof, :message}, {:message, CucumberMessages.ParameterType}},
parse_error: {16, {:oneof, :message}, {:message, CucumberMessages.ParseError}},
pickle: {3, {:oneof, :message}, {:message, CucumberMessages.Pickle}},
source: {1, {:oneof, :message}, {:message, CucumberMessages.Source}},
step_definition: {4, {:oneof, :message}, {:message, CucumberMessages.StepDefinition}},
test_case: {7, {:oneof, :message}, {:message, CucumberMessages.TestCase}},
test_case_finished:
{14, {:oneof, :message}, {:message, CucumberMessages.TestCaseFinished}},
test_case_started:
{10, {:oneof, :message}, {:message, CucumberMessages.TestCaseStarted}},
test_run_finished:
{15, {:oneof, :message}, {:message, CucumberMessages.TestRunFinished}},
test_run_started: {9, {:oneof, :message}, {:message, CucumberMessages.TestRunStarted}},
test_step_finished:
{13, {:oneof, :message}, {:message, CucumberMessages.TestStepFinished}},
test_step_started:
{11, {:oneof, :message}, {:message, CucumberMessages.TestStepStarted}},
undefined_parameter_type:
{8, {:oneof, :message}, {:message, CucumberMessages.UndefinedParameterType}}
}
end
@spec required_fields() :: []
def(required_fields()) do
[]
end
@spec unknown_fields(struct) :: [{non_neg_integer, Protox.Types.tag(), binary}]
def(unknown_fields(msg)) do
msg.__uf__()
end
@spec unknown_fields_name() :: :__uf__
def(unknown_fields_name()) do
:__uf__
end
@spec clear_unknown_fields(struct) :: struct
def(clear_unknown_fields(msg)) do
struct!(msg, [{unknown_fields_name(), []}])
end
@spec syntax() :: atom
def(syntax()) do
:proto3
end
[
@spec(
default(atom) :: {:ok, boolean | integer | String.t() | binary | float} | {:error, atom}
),
[
def(default(:source)) do
{:error, :no_default_value}
end,
def(default(:gherkin_document)) do
{:error, :no_default_value}
end,
def(default(:pickle)) do
{:error, :no_default_value}
end,
def(default(:step_definition)) do
{:error, :no_default_value}
end,
def(default(:hook)) do
{:error, :no_default_value}
end,
def(default(:parameter_type)) do
{:error, :no_default_value}
end,
def(default(:test_case)) do
{:error, :no_default_value}
end,
def(default(:undefined_parameter_type)) do
{:error, :no_default_value}
end,
def(default(:test_run_started)) do
{:error, :no_default_value}
end,
def(default(:test_case_started)) do
{:error, :no_default_value}
end,
def(default(:test_step_started)) do
{:error, :no_default_value}
end,
def(default(:attachment)) do
{:error, :no_default_value}
end,
def(default(:test_step_finished)) do
{:error, :no_default_value}
end,
def(default(:test_case_finished)) do
{:error, :no_default_value}
end,
def(default(:test_run_finished)) do
{:error, :no_default_value}
end,
def(default(:parse_error)) do
{:error, :no_default_value}
end,
def(default(:meta)) do
{:error, :no_default_value}
end
],
def(default(_)) do
{:error, :no_such_field}
end
]
)
[]
end,
defmodule(CucumberMessages.GherkinDocument.Feature.Step.DocString) do
@moduledoc false
(
defstruct(location: nil, media_type: "", content: "", delimiter: "", __uf__: [])
(
@spec encode(struct) :: {:ok, iodata} | {:error, any}
def(encode(msg)) do
try do
{:ok, encode!(msg)}
rescue
e ->
{:error, e}
end
end
@spec encode!(struct) :: iodata | no_return
def(encode!(msg)) do
[]
|> encode_location(msg)
|> encode_media_type(msg)
|> encode_content(msg)
|> encode_delimiter(msg)
|> encode_unknown_fields(msg)
end
[]
[
defp(encode_location(acc, msg)) do
field_value = msg.location()
if(field_value == nil) do
acc
else
[acc, "\n", Protox.Encode.encode_message(field_value)]
end
end,
defp(encode_media_type(acc, msg)) do
field_value = msg.media_type()
if(field_value == "") do
acc
else
[acc, <<18>>, Protox.Encode.encode_string(field_value)]
end
end,
defp(encode_content(acc, msg)) do
field_value = msg.content()
if(field_value == "") do
acc
else
[acc, <<26>>, Protox.Encode.encode_string(field_value)]
end
end,
defp(encode_delimiter(acc, msg)) do
field_value = msg.delimiter()
if(field_value == "") do
acc
else
[acc, "\"", Protox.Encode.encode_string(field_value)]
end
end
]
defp(encode_unknown_fields(acc, msg)) do
Enum.reduce(msg.__struct__.unknown_fields(msg), acc, fn {tag, wire_type, bytes}, acc ->
case(wire_type) do
0 ->
[acc, Protox.Encode.make_key_bytes(tag, :int32), bytes]
1 ->
[acc, Protox.Encode.make_key_bytes(tag, :double), bytes]
2 ->
len_bytes = bytes |> byte_size() |> Protox.Varint.encode()
[acc, Protox.Encode.make_key_bytes(tag, :packed), len_bytes, bytes]
5 ->
[acc, Protox.Encode.make_key_bytes(tag, :float), bytes]
end
end)
end
)
(
@spec decode(binary) :: {:ok, struct} | {:error, any}
def(decode(bytes)) do
try do
{:ok, decode!(bytes)}
rescue
Protox.IllegalTagError ->
{:error, :illegal_tag}
e in Protox.RequiredFieldsError ->
{:error, {:missing_fields, e.missing_fields}}
e in Protox.DecodingError ->
{:error, {e.reason, e.binary}}
e ->
{:error, e}
end
end
(
@spec decode!(binary) :: struct | no_return
def(decode!(bytes)) do
parse_key_value(
bytes,
struct(CucumberMessages.GherkinDocument.Feature.Step.DocString)
)
end
)
(
@spec parse_key_value(binary, struct) :: struct
defp(parse_key_value(<<>>, msg)) do
msg
end
defp(parse_key_value(bytes, msg)) do
{field, rest} =
case(Protox.Decode.parse_key(bytes)) do
{0, _, _} ->
raise(%Protox.IllegalTagError{})
{1, _, bytes} ->
{len, bytes} = Protox.Varint.decode(bytes)
<<delimited::binary-size(len), rest::binary>> = bytes
value = CucumberMessages.Location.decode!(delimited)
field = {:location, Protox.Message.merge(msg.location(), value)}
{field, rest}
{2, _, bytes} ->
{len, bytes} = Protox.Varint.decode(bytes)
<<delimited::binary-size(len), rest::binary>> = bytes
value = delimited
field = {:media_type, value}
{field, rest}
{3, _, bytes} ->
{len, bytes} = Protox.Varint.decode(bytes)
<<delimited::binary-size(len), rest::binary>> = bytes
value = delimited
field = {:content, value}
{field, rest}
{4, _, bytes} ->
{len, bytes} = Protox.Varint.decode(bytes)
<<delimited::binary-size(len), rest::binary>> = bytes
value = delimited
field = {:delimiter, value}
{field, rest}
{tag, wire_type, rest} ->
{value, new_rest} = Protox.Decode.parse_unknown(tag, wire_type, rest)
field =
{msg.__struct__.unknown_fields_name,
[value | msg.__struct__.unknown_fields(msg)]}
{field, new_rest}
end
msg_updated = struct(msg, [field])
parse_key_value(rest, msg_updated)
end
)
[]
)
@spec defs() :: %{
required(non_neg_integer) => {atom, Protox.Types.kind(), Protox.Types.type()}
}
def(defs()) do
%{
1 => {:location, {:default, nil}, {:message, CucumberMessages.Location}},
2 => {:media_type, {:default, ""}, :string},
3 => {:content, {:default, ""}, :string},
4 => {:delimiter, {:default, ""}, :string}
}
end
@spec defs_by_name() :: %{
required(atom) => {non_neg_integer, Protox.Types.kind(), Protox.Types.type()}
}
def(defs_by_name()) do
%{
content: {3, {:default, ""}, :string},
delimiter: {4, {:default, ""}, :string},
location: {1, {:default, nil}, {:message, CucumberMessages.Location}},
media_type: {2, {:default, ""}, :string}
}
end
@spec required_fields() :: []
def(required_fields()) do
[]
end
@spec unknown_fields(struct) :: [{non_neg_integer, Protox.Types.tag(), binary}]
def(unknown_fields(msg)) do
msg.__uf__()
end
@spec unknown_fields_name() :: :__uf__
def(unknown_fields_name()) do
:__uf__
end
@spec clear_unknown_fields(struct) :: struct
def(clear_unknown_fields(msg)) do
struct!(msg, [{unknown_fields_name(), []}])
end
@spec syntax() :: atom
def(syntax()) do
:proto3
end
[
@spec(
default(atom) :: {:ok, boolean | integer | String.t() | binary | float} | {:error, atom}
),
[
def(default(:location)) do
{:ok, nil}
end,
def(default(:media_type)) do
{:ok, ""}
end,
def(default(:content)) do
{:ok, ""}
end,
def(default(:delimiter)) do
{:ok, ""}
end
],
def(default(_)) do
{:error, :no_such_field}
end
]
)
[]
end,
defmodule(CucumberMessages.Timestamp) do
@moduledoc false
(
defstruct(seconds: 0, nanos: 0, __uf__: [])
(
@spec encode(struct) :: {:ok, iodata} | {:error, any}
def(encode(msg)) do
try do
{:ok, encode!(msg)}
rescue
e ->
{:error, e}
end
end
@spec encode!(struct) :: iodata | no_return
def(encode!(msg)) do
[] |> encode_seconds(msg) |> encode_nanos(msg) |> encode_unknown_fields(msg)
end
[]
[
defp(encode_seconds(acc, msg)) do
field_value = msg.seconds()
if(field_value == 0) do
acc
else
[acc, "\b", Protox.Encode.encode_int64(field_value)]
end
end,
defp(encode_nanos(acc, msg)) do
field_value = msg.nanos()
if(field_value == 0) do
acc
else
[acc, <<16>>, Protox.Encode.encode_int32(field_value)]
end
end
]
defp(encode_unknown_fields(acc, msg)) do
Enum.reduce(msg.__struct__.unknown_fields(msg), acc, fn {tag, wire_type, bytes}, acc ->
case(wire_type) do
0 ->
[acc, Protox.Encode.make_key_bytes(tag, :int32), bytes]
1 ->
[acc, Protox.Encode.make_key_bytes(tag, :double), bytes]
2 ->
len_bytes = bytes |> byte_size() |> Protox.Varint.encode()
[acc, Protox.Encode.make_key_bytes(tag, :packed), len_bytes, bytes]
5 ->
[acc, Protox.Encode.make_key_bytes(tag, :float), bytes]
end
end)
end
)
(
@spec decode(binary) :: {:ok, struct} | {:error, any}
def(decode(bytes)) do
try do
{:ok, decode!(bytes)}
rescue
Protox.IllegalTagError ->
{:error, :illegal_tag}
e in Protox.RequiredFieldsError ->
{:error, {:missing_fields, e.missing_fields}}
e in Protox.DecodingError ->
{:error, {e.reason, e.binary}}
e ->
{:error, e}
end
end
(
@spec decode!(binary) :: struct | no_return
def(decode!(bytes)) do
parse_key_value(bytes, struct(CucumberMessages.Timestamp))
end
)
(
@spec parse_key_value(binary, struct) :: struct
defp(parse_key_value(<<>>, msg)) do
msg
end
defp(parse_key_value(bytes, msg)) do
{field, rest} =
case(Protox.Decode.parse_key(bytes)) do
{0, _, _} ->
raise(%Protox.IllegalTagError{})
{1, _, bytes} ->
{value, rest} = Protox.Decode.parse_int64(bytes)
field = {:seconds, value}
{field, rest}
{2, _, bytes} ->
{value, rest} = Protox.Decode.parse_int32(bytes)
field = {:nanos, value}
{field, rest}
{tag, wire_type, rest} ->
{value, new_rest} = Protox.Decode.parse_unknown(tag, wire_type, rest)
field =
{msg.__struct__.unknown_fields_name,
[value | msg.__struct__.unknown_fields(msg)]}
{field, new_rest}
end
msg_updated = struct(msg, [field])
parse_key_value(rest, msg_updated)
end
)
[]
)
@spec defs() :: %{
required(non_neg_integer) => {atom, Protox.Types.kind(), Protox.Types.type()}
}
def(defs()) do
%{1 => {:seconds, {:default, 0}, :int64}, 2 => {:nanos, {:default, 0}, :int32}}
end
@spec defs_by_name() :: %{
required(atom) => {non_neg_integer, Protox.Types.kind(), Protox.Types.type()}
}
def(defs_by_name()) do
%{nanos: {2, {:default, 0}, :int32}, seconds: {1, {:default, 0}, :int64}}
end
@spec required_fields() :: []
def(required_fields()) do
[]
end
@spec unknown_fields(struct) :: [{non_neg_integer, Protox.Types.tag(), binary}]
def(unknown_fields(msg)) do
msg.__uf__()
end
@spec unknown_fields_name() :: :__uf__
def(unknown_fields_name()) do
:__uf__
end
@spec clear_unknown_fields(struct) :: struct
def(clear_unknown_fields(msg)) do
struct!(msg, [{unknown_fields_name(), []}])
end
@spec syntax() :: atom
def(syntax()) do
:proto3
end
[
@spec(
default(atom) :: {:ok, boolean | integer | String.t() | binary | float} | {:error, atom}
),
[
def(default(:seconds)) do
{:ok, 0}
end,
def(default(:nanos)) do
{:ok, 0}
end
],
def(default(_)) do
{:error, :no_such_field}
end
]
)
[]
end,
defmodule(CucumberMessages.TestCase.TestStep) do
@moduledoc false
(
defstruct(
id: "",
pickle_step_id: "",
step_definition_ids: [],
step_match_arguments_lists: [],
hook_id: "",
__uf__: []
)
(
@spec encode(struct) :: {:ok, iodata} | {:error, any}
def(encode(msg)) do
try do
{:ok, encode!(msg)}
rescue
e ->
{:error, e}
end
end
@spec encode!(struct) :: iodata | no_return
def(encode!(msg)) do
[]
|> encode_id(msg)
|> encode_pickle_step_id(msg)
|> encode_step_definition_ids(msg)
|> encode_step_match_arguments_lists(msg)
|> encode_hook_id(msg)
|> encode_unknown_fields(msg)
end
[]
[
defp(encode_id(acc, msg)) do
field_value = msg.id()
if(field_value == "") do
acc
else
[acc, "\n", Protox.Encode.encode_string(field_value)]
end
end,
defp(encode_pickle_step_id(acc, msg)) do
field_value = msg.pickle_step_id()
if(field_value == "") do
acc
else
[acc, <<18>>, Protox.Encode.encode_string(field_value)]
end
end,
defp(encode_step_definition_ids(acc, msg)) do
case(msg.step_definition_ids()) do
[] ->
acc
values ->
[
acc,
Enum.reduce(values, [], fn value, acc ->
[acc, <<26>>, Protox.Encode.encode_string(value)]
end)
]
end
end,
defp(encode_step_match_arguments_lists(acc, msg)) do
case(msg.step_match_arguments_lists()) do
[] ->
acc
values ->
[
acc,
Enum.reduce(values, [], fn value, acc ->
[acc, "\"", Protox.Encode.encode_message(value)]
end)
]
end
end,
defp(encode_hook_id(acc, msg)) do
field_value = msg.hook_id()
if(field_value == "") do
acc
else
[acc, "*", Protox.Encode.encode_string(field_value)]
end
end
]
defp(encode_unknown_fields(acc, msg)) do
Enum.reduce(msg.__struct__.unknown_fields(msg), acc, fn {tag, wire_type, bytes}, acc ->
case(wire_type) do
0 ->
[acc, Protox.Encode.make_key_bytes(tag, :int32), bytes]
1 ->
[acc, Protox.Encode.make_key_bytes(tag, :double), bytes]
2 ->
len_bytes = bytes |> byte_size() |> Protox.Varint.encode()
[acc, Protox.Encode.make_key_bytes(tag, :packed), len_bytes, bytes]
5 ->
[acc, Protox.Encode.make_key_bytes(tag, :float), bytes]
end
end)
end
)
(
@spec decode(binary) :: {:ok, struct} | {:error, any}
def(decode(bytes)) do
try do
{:ok, decode!(bytes)}
rescue
Protox.IllegalTagError ->
{:error, :illegal_tag}
e in Protox.RequiredFieldsError ->
{:error, {:missing_fields, e.missing_fields}}
e in Protox.DecodingError ->
{:error, {e.reason, e.binary}}
e ->
{:error, e}
end
end
(
@spec decode!(binary) :: struct | no_return
def(decode!(bytes)) do
parse_key_value(bytes, struct(CucumberMessages.TestCase.TestStep))
end
)
(
@spec parse_key_value(binary, struct) :: struct
defp(parse_key_value(<<>>, msg)) do
msg
end
defp(parse_key_value(bytes, msg)) do
{field, rest} =
case(Protox.Decode.parse_key(bytes)) do
{0, _, _} ->
raise(%Protox.IllegalTagError{})
{1, _, bytes} ->
{len, bytes} = Protox.Varint.decode(bytes)
<<delimited::binary-size(len), rest::binary>> = bytes
value = delimited
field = {:id, value}
{field, rest}
{2, _, bytes} ->
{len, bytes} = Protox.Varint.decode(bytes)
<<delimited::binary-size(len), rest::binary>> = bytes
value = delimited
field = {:pickle_step_id, value}
{field, rest}
{3, _, bytes} ->
{len, bytes} = Protox.Varint.decode(bytes)
<<delimited::binary-size(len), rest::binary>> = bytes
value = delimited
field = {:step_definition_ids, msg.step_definition_ids() ++ List.wrap(value)}
{field, rest}
{4, _, bytes} ->
{len, bytes} = Protox.Varint.decode(bytes)
<<delimited::binary-size(len), rest::binary>> = bytes
value =
CucumberMessages.TestCase.TestStep.StepMatchArgumentsList.decode!(delimited)
field =
{:step_match_arguments_lists,
msg.step_match_arguments_lists() ++ List.wrap(value)}
{field, rest}
{5, _, bytes} ->
{len, bytes} = Protox.Varint.decode(bytes)
<<delimited::binary-size(len), rest::binary>> = bytes
value = delimited
field = {:hook_id, value}
{field, rest}
{tag, wire_type, rest} ->
{value, new_rest} = Protox.Decode.parse_unknown(tag, wire_type, rest)
field =
{msg.__struct__.unknown_fields_name,
[value | msg.__struct__.unknown_fields(msg)]}
{field, new_rest}
end
msg_updated = struct(msg, [field])
parse_key_value(rest, msg_updated)
end
)
[]
)
@spec defs() :: %{
required(non_neg_integer) => {atom, Protox.Types.kind(), Protox.Types.type()}
}
def(defs()) do
%{
1 => {:id, {:default, ""}, :string},
2 => {:pickle_step_id, {:default, ""}, :string},
3 => {:step_definition_ids, :unpacked, :string},
4 =>
{:step_match_arguments_lists, :unpacked,
{:message, CucumberMessages.TestCase.TestStep.StepMatchArgumentsList}},
5 => {:hook_id, {:default, ""}, :string}
}
end
@spec defs_by_name() :: %{
required(atom) => {non_neg_integer, Protox.Types.kind(), Protox.Types.type()}
}
def(defs_by_name()) do
%{
hook_id: {5, {:default, ""}, :string},
id: {1, {:default, ""}, :string},
pickle_step_id: {2, {:default, ""}, :string},
step_definition_ids: {3, :unpacked, :string},
step_match_arguments_lists:
{4, :unpacked, {:message, CucumberMessages.TestCase.TestStep.StepMatchArgumentsList}}
}
end
@spec required_fields() :: []
def(required_fields()) do
[]
end
@spec unknown_fields(struct) :: [{non_neg_integer, Protox.Types.tag(), binary}]
def(unknown_fields(msg)) do
msg.__uf__()
end
@spec unknown_fields_name() :: :__uf__
def(unknown_fields_name()) do
:__uf__
end
@spec clear_unknown_fields(struct) :: struct
def(clear_unknown_fields(msg)) do
struct!(msg, [{unknown_fields_name(), []}])
end
@spec syntax() :: atom
def(syntax()) do
:proto3
end
[
@spec(
default(atom) :: {:ok, boolean | integer | String.t() | binary | float} | {:error, atom}
),
[
def(default(:id)) do
{:ok, ""}
end,
def(default(:pickle_step_id)) do
{:ok, ""}
end,
def(default(:step_definition_ids)) do
{:error, :no_default_value}
end,
def(default(:step_match_arguments_lists)) do
{:error, :no_default_value}
end,
def(default(:hook_id)) do
{:ok, ""}
end
],
def(default(_)) do
{:error, :no_such_field}
end
]
)
[]
end,
defmodule(CucumberMessages.Duration) do
@moduledoc false
(
defstruct(seconds: 0, nanos: 0, __uf__: [])
(
@spec encode(struct) :: {:ok, iodata} | {:error, any}
def(encode(msg)) do
try do
{:ok, encode!(msg)}
rescue
e ->
{:error, e}
end
end
@spec encode!(struct) :: iodata | no_return
def(encode!(msg)) do
[] |> encode_seconds(msg) |> encode_nanos(msg) |> encode_unknown_fields(msg)
end
[]
[
defp(encode_seconds(acc, msg)) do
field_value = msg.seconds()
if(field_value == 0) do
acc
else
[acc, "\b", Protox.Encode.encode_int64(field_value)]
end
end,
defp(encode_nanos(acc, msg)) do
field_value = msg.nanos()
if(field_value == 0) do
acc
else
[acc, <<16>>, Protox.Encode.encode_int32(field_value)]
end
end
]
defp(encode_unknown_fields(acc, msg)) do
Enum.reduce(msg.__struct__.unknown_fields(msg), acc, fn {tag, wire_type, bytes}, acc ->
case(wire_type) do
0 ->
[acc, Protox.Encode.make_key_bytes(tag, :int32), bytes]
1 ->
[acc, Protox.Encode.make_key_bytes(tag, :double), bytes]
2 ->
len_bytes = bytes |> byte_size() |> Protox.Varint.encode()
[acc, Protox.Encode.make_key_bytes(tag, :packed), len_bytes, bytes]
5 ->
[acc, Protox.Encode.make_key_bytes(tag, :float), bytes]
end
end)
end
)
(
@spec decode(binary) :: {:ok, struct} | {:error, any}
def(decode(bytes)) do
try do
{:ok, decode!(bytes)}
rescue
Protox.IllegalTagError ->
{:error, :illegal_tag}
e in Protox.RequiredFieldsError ->
{:error, {:missing_fields, e.missing_fields}}
e in Protox.DecodingError ->
{:error, {e.reason, e.binary}}
e ->
{:error, e}
end
end
(
@spec decode!(binary) :: struct | no_return
def(decode!(bytes)) do
parse_key_value(bytes, struct(CucumberMessages.Duration))
end
)
(
@spec parse_key_value(binary, struct) :: struct
defp(parse_key_value(<<>>, msg)) do
msg
end
defp(parse_key_value(bytes, msg)) do
{field, rest} =
case(Protox.Decode.parse_key(bytes)) do
{0, _, _} ->
raise(%Protox.IllegalTagError{})
{1, _, bytes} ->
{value, rest} = Protox.Decode.parse_int64(bytes)
field = {:seconds, value}
{field, rest}
{2, _, bytes} ->
{value, rest} = Protox.Decode.parse_int32(bytes)
field = {:nanos, value}
{field, rest}
{tag, wire_type, rest} ->
{value, new_rest} = Protox.Decode.parse_unknown(tag, wire_type, rest)
field =
{msg.__struct__.unknown_fields_name,
[value | msg.__struct__.unknown_fields(msg)]}
{field, new_rest}
end
msg_updated = struct(msg, [field])
parse_key_value(rest, msg_updated)
end
)
[]
)
@spec defs() :: %{
required(non_neg_integer) => {atom, Protox.Types.kind(), Protox.Types.type()}
}
def(defs()) do
%{1 => {:seconds, {:default, 0}, :int64}, 2 => {:nanos, {:default, 0}, :int32}}
end
@spec defs_by_name() :: %{
required(atom) => {non_neg_integer, Protox.Types.kind(), Protox.Types.type()}
}
def(defs_by_name()) do
%{nanos: {2, {:default, 0}, :int32}, seconds: {1, {:default, 0}, :int64}}
end
@spec required_fields() :: []
def(required_fields()) do
[]
end
@spec unknown_fields(struct) :: [{non_neg_integer, Protox.Types.tag(), binary}]
def(unknown_fields(msg)) do
msg.__uf__()
end
@spec unknown_fields_name() :: :__uf__
def(unknown_fields_name()) do
:__uf__
end
@spec clear_unknown_fields(struct) :: struct
def(clear_unknown_fields(msg)) do
struct!(msg, [{unknown_fields_name(), []}])
end
@spec syntax() :: atom
def(syntax()) do
:proto3
end
[
@spec(
default(atom) :: {:ok, boolean | integer | String.t() | binary | float} | {:error, atom}
),
[
def(default(:seconds)) do
{:ok, 0}
end,
def(default(:nanos)) do
{:ok, 0}
end
],
def(default(_)) do
{:error, :no_such_field}
end
]
)
[]
end,
defmodule(CucumberMessages.GherkinDocument.Feature.FeatureChild) do
@moduledoc false
(
defstruct(value: nil, __uf__: [])
(
@spec encode(struct) :: {:ok, iodata} | {:error, any}
def(encode(msg)) do
try do
{:ok, encode!(msg)}
rescue
e ->
{:error, e}
end
end
@spec encode!(struct) :: iodata | no_return
def(encode!(msg)) do
[] |> encode_value(msg) |> encode_unknown_fields(msg)
end
[
defp(encode_value(acc, msg)) do
case(msg.value()) do
nil ->
acc
{:rule, _field_value} ->
encode_rule(acc, msg)
{:background, _field_value} ->
encode_background(acc, msg)
{:scenario, _field_value} ->
encode_scenario(acc, msg)
end
end
]
[
defp(encode_rule(acc, msg)) do
{_, field_value} = msg.value()
[acc, "\n", Protox.Encode.encode_message(field_value)]
end,
defp(encode_background(acc, msg)) do
{_, field_value} = msg.value()
[acc, <<18>>, Protox.Encode.encode_message(field_value)]
end,
defp(encode_scenario(acc, msg)) do
{_, field_value} = msg.value()
[acc, <<26>>, Protox.Encode.encode_message(field_value)]
end
]
defp(encode_unknown_fields(acc, msg)) do
Enum.reduce(msg.__struct__.unknown_fields(msg), acc, fn {tag, wire_type, bytes}, acc ->
case(wire_type) do
0 ->
[acc, Protox.Encode.make_key_bytes(tag, :int32), bytes]
1 ->
[acc, Protox.Encode.make_key_bytes(tag, :double), bytes]
2 ->
len_bytes = bytes |> byte_size() |> Protox.Varint.encode()
[acc, Protox.Encode.make_key_bytes(tag, :packed), len_bytes, bytes]
5 ->
[acc, Protox.Encode.make_key_bytes(tag, :float), bytes]
end
end)
end
)
(
@spec decode(binary) :: {:ok, struct} | {:error, any}
def(decode(bytes)) do
try do
{:ok, decode!(bytes)}
rescue
Protox.IllegalTagError ->
{:error, :illegal_tag}
e in Protox.RequiredFieldsError ->
{:error, {:missing_fields, e.missing_fields}}
e in Protox.DecodingError ->
{:error, {e.reason, e.binary}}
e ->
{:error, e}
end
end
(
@spec decode!(binary) :: struct | no_return
def(decode!(bytes)) do
parse_key_value(bytes, struct(CucumberMessages.GherkinDocument.Feature.FeatureChild))
end
)
(
@spec parse_key_value(binary, struct) :: struct
defp(parse_key_value(<<>>, msg)) do
msg
end
defp(parse_key_value(bytes, msg)) do
{field, rest} =
case(Protox.Decode.parse_key(bytes)) do
{0, _, _} ->
raise(%Protox.IllegalTagError{})
{1, _, bytes} ->
{len, bytes} = Protox.Varint.decode(bytes)
<<delimited::binary-size(len), rest::binary>> = bytes
value =
CucumberMessages.GherkinDocument.Feature.FeatureChild.Rule.decode!(delimited)
field =
case(msg.value()) do
{:rule, previous_value} ->
{:value, {:rule, Protox.Message.merge(previous_value, value)}}
_ ->
{:value, {:rule, value}}
end
{field, rest}
{2, _, bytes} ->
{len, bytes} = Protox.Varint.decode(bytes)
<<delimited::binary-size(len), rest::binary>> = bytes
value = CucumberMessages.GherkinDocument.Feature.Background.decode!(delimited)
field =
case(msg.value()) do
{:background, previous_value} ->
{:value, {:background, Protox.Message.merge(previous_value, value)}}
_ ->
{:value, {:background, value}}
end
{field, rest}
{3, _, bytes} ->
{len, bytes} = Protox.Varint.decode(bytes)
<<delimited::binary-size(len), rest::binary>> = bytes
value = CucumberMessages.GherkinDocument.Feature.Scenario.decode!(delimited)
field =
case(msg.value()) do
{:scenario, previous_value} ->
{:value, {:scenario, Protox.Message.merge(previous_value, value)}}
_ ->
{:value, {:scenario, value}}
end
{field, rest}
{tag, wire_type, rest} ->
{value, new_rest} = Protox.Decode.parse_unknown(tag, wire_type, rest)
field =
{msg.__struct__.unknown_fields_name,
[value | msg.__struct__.unknown_fields(msg)]}
{field, new_rest}
end
msg_updated = struct(msg, [field])
parse_key_value(rest, msg_updated)
end
)
[]
)
@spec defs() :: %{
required(non_neg_integer) => {atom, Protox.Types.kind(), Protox.Types.type()}
}
def(defs()) do
%{
1 =>
{:rule, {:oneof, :value},
{:message, CucumberMessages.GherkinDocument.Feature.FeatureChild.Rule}},
2 =>
{:background, {:oneof, :value},
{:message, CucumberMessages.GherkinDocument.Feature.Background}},
3 =>
{:scenario, {:oneof, :value},
{:message, CucumberMessages.GherkinDocument.Feature.Scenario}}
}
end
@spec defs_by_name() :: %{
required(atom) => {non_neg_integer, Protox.Types.kind(), Protox.Types.type()}
}
def(defs_by_name()) do
%{
background:
{2, {:oneof, :value}, {:message, CucumberMessages.GherkinDocument.Feature.Background}},
rule:
{1, {:oneof, :value},
{:message, CucumberMessages.GherkinDocument.Feature.FeatureChild.Rule}},
scenario:
{3, {:oneof, :value}, {:message, CucumberMessages.GherkinDocument.Feature.Scenario}}
}
end
@spec required_fields() :: []
def(required_fields()) do
[]
end
@spec unknown_fields(struct) :: [{non_neg_integer, Protox.Types.tag(), binary}]
def(unknown_fields(msg)) do
msg.__uf__()
end
@spec unknown_fields_name() :: :__uf__
def(unknown_fields_name()) do
:__uf__
end
@spec clear_unknown_fields(struct) :: struct
def(clear_unknown_fields(msg)) do
struct!(msg, [{unknown_fields_name(), []}])
end
@spec syntax() :: atom
def(syntax()) do
:proto3
end
[
@spec(
default(atom) :: {:ok, boolean | integer | String.t() | binary | float} | {:error, atom}
),
[
def(default(:rule)) do
{:error, :no_default_value}
end,
def(default(:background)) do
{:error, :no_default_value}
end,
def(default(:scenario)) do
{:error, :no_default_value}
end
],
def(default(_)) do
{:error, :no_such_field}
end
]
)
[]
end,
defmodule(CucumberMessages.GherkinDocument.Feature.Scenario) do
@moduledoc false
(
defstruct(
location: nil,
tags: [],
keyword: "",
name: "",
description: "",
steps: [],
examples: [],
id: "",
__uf__: []
)
(
@spec encode(struct) :: {:ok, iodata} | {:error, any}
def(encode(msg)) do
try do
{:ok, encode!(msg)}
rescue
e ->
{:error, e}
end
end
@spec encode!(struct) :: iodata | no_return
def(encode!(msg)) do
[]
|> encode_location(msg)
|> encode_tags(msg)
|> encode_keyword(msg)
|> encode_name(msg)
|> encode_description(msg)
|> encode_steps(msg)
|> encode_examples(msg)
|> encode_id(msg)
|> encode_unknown_fields(msg)
end
[]
[
defp(encode_location(acc, msg)) do
field_value = msg.location()
if(field_value == nil) do
acc
else
[acc, "\n", Protox.Encode.encode_message(field_value)]
end
end,
defp(encode_tags(acc, msg)) do
case(msg.tags()) do
[] ->
acc
values ->
[
acc,
Enum.reduce(values, [], fn value, acc ->
[acc, <<18>>, Protox.Encode.encode_message(value)]
end)
]
end
end,
defp(encode_keyword(acc, msg)) do
field_value = msg.keyword()
if(field_value == "") do
acc
else
[acc, <<26>>, Protox.Encode.encode_string(field_value)]
end
end,
defp(encode_name(acc, msg)) do
field_value = msg.name()
if(field_value == "") do
acc
else
[acc, "\"", Protox.Encode.encode_string(field_value)]
end
end,
defp(encode_description(acc, msg)) do
field_value = msg.description()
if(field_value == "") do
acc
else
[acc, "*", Protox.Encode.encode_string(field_value)]
end
end,
defp(encode_steps(acc, msg)) do
case(msg.steps()) do
[] ->
acc
values ->
[
acc,
Enum.reduce(values, [], fn value, acc ->
[acc, "2", Protox.Encode.encode_message(value)]
end)
]
end
end,
defp(encode_examples(acc, msg)) do
case(msg.examples()) do
[] ->
acc
values ->
[
acc,
Enum.reduce(values, [], fn value, acc ->
[acc, ":", Protox.Encode.encode_message(value)]
end)
]
end
end,
defp(encode_id(acc, msg)) do
field_value = msg.id()
if(field_value == "") do
acc
else
[acc, "B", Protox.Encode.encode_string(field_value)]
end
end
]
defp(encode_unknown_fields(acc, msg)) do
Enum.reduce(msg.__struct__.unknown_fields(msg), acc, fn {tag, wire_type, bytes}, acc ->
case(wire_type) do
0 ->
[acc, Protox.Encode.make_key_bytes(tag, :int32), bytes]
1 ->
[acc, Protox.Encode.make_key_bytes(tag, :double), bytes]
2 ->
len_bytes = bytes |> byte_size() |> Protox.Varint.encode()
[acc, Protox.Encode.make_key_bytes(tag, :packed), len_bytes, bytes]
5 ->
[acc, Protox.Encode.make_key_bytes(tag, :float), bytes]
end
end)
end
)
(
@spec decode(binary) :: {:ok, struct} | {:error, any}
def(decode(bytes)) do
try do
{:ok, decode!(bytes)}
rescue
Protox.IllegalTagError ->
{:error, :illegal_tag}
e in Protox.RequiredFieldsError ->
{:error, {:missing_fields, e.missing_fields}}
e in Protox.DecodingError ->
{:error, {e.reason, e.binary}}
e ->
{:error, e}
end
end
(
@spec decode!(binary) :: struct | no_return
def(decode!(bytes)) do
parse_key_value(bytes, struct(CucumberMessages.GherkinDocument.Feature.Scenario))
end
)
(
@spec parse_key_value(binary, struct) :: struct
defp(parse_key_value(<<>>, msg)) do
msg
end
defp(parse_key_value(bytes, msg)) do
{field, rest} =
case(Protox.Decode.parse_key(bytes)) do
{0, _, _} ->
raise(%Protox.IllegalTagError{})
{1, _, bytes} ->
{len, bytes} = Protox.Varint.decode(bytes)
<<delimited::binary-size(len), rest::binary>> = bytes
value = CucumberMessages.Location.decode!(delimited)
field = {:location, Protox.Message.merge(msg.location(), value)}
{field, rest}
{2, _, bytes} ->
{len, bytes} = Protox.Varint.decode(bytes)
<<delimited::binary-size(len), rest::binary>> = bytes
value = CucumberMessages.GherkinDocument.Feature.Tag.decode!(delimited)
field = {:tags, msg.tags() ++ List.wrap(value)}
{field, rest}
{3, _, bytes} ->
{len, bytes} = Protox.Varint.decode(bytes)
<<delimited::binary-size(len), rest::binary>> = bytes
value = delimited
field = {:keyword, value}
{field, rest}
{4, _, bytes} ->
{len, bytes} = Protox.Varint.decode(bytes)
<<delimited::binary-size(len), rest::binary>> = bytes
value = delimited
field = {:name, value}
{field, rest}
{5, _, bytes} ->
{len, bytes} = Protox.Varint.decode(bytes)
<<delimited::binary-size(len), rest::binary>> = bytes
value = delimited
field = {:description, value}
{field, rest}
{6, _, bytes} ->
{len, bytes} = Protox.Varint.decode(bytes)
<<delimited::binary-size(len), rest::binary>> = bytes
value = CucumberMessages.GherkinDocument.Feature.Step.decode!(delimited)
field = {:steps, msg.steps() ++ List.wrap(value)}
{field, rest}
{7, _, bytes} ->
{len, bytes} = Protox.Varint.decode(bytes)
<<delimited::binary-size(len), rest::binary>> = bytes
value =
CucumberMessages.GherkinDocument.Feature.Scenario.Examples.decode!(delimited)
field = {:examples, msg.examples() ++ List.wrap(value)}
{field, rest}
{8, _, bytes} ->
{len, bytes} = Protox.Varint.decode(bytes)
<<delimited::binary-size(len), rest::binary>> = bytes
value = delimited
field = {:id, value}
{field, rest}
{tag, wire_type, rest} ->
{value, new_rest} = Protox.Decode.parse_unknown(tag, wire_type, rest)
field =
{msg.__struct__.unknown_fields_name,
[value | msg.__struct__.unknown_fields(msg)]}
{field, new_rest}
end
msg_updated = struct(msg, [field])
parse_key_value(rest, msg_updated)
end
)
[]
)
@spec defs() :: %{
required(non_neg_integer) => {atom, Protox.Types.kind(), Protox.Types.type()}
}
def(defs()) do
%{
1 => {:location, {:default, nil}, {:message, CucumberMessages.Location}},
2 => {:tags, :unpacked, {:message, CucumberMessages.GherkinDocument.Feature.Tag}},
3 => {:keyword, {:default, ""}, :string},
4 => {:name, {:default, ""}, :string},
5 => {:description, {:default, ""}, :string},
6 => {:steps, :unpacked, {:message, CucumberMessages.GherkinDocument.Feature.Step}},
7 =>
{:examples, :unpacked,
{:message, CucumberMessages.GherkinDocument.Feature.Scenario.Examples}},
8 => {:id, {:default, ""}, :string}
}
end
@spec defs_by_name() :: %{
required(atom) => {non_neg_integer, Protox.Types.kind(), Protox.Types.type()}
}
def(defs_by_name()) do
%{
description: {5, {:default, ""}, :string},
examples:
{7, :unpacked, {:message, CucumberMessages.GherkinDocument.Feature.Scenario.Examples}},
id: {8, {:default, ""}, :string},
keyword: {3, {:default, ""}, :string},
location: {1, {:default, nil}, {:message, CucumberMessages.Location}},
name: {4, {:default, ""}, :string},
steps: {6, :unpacked, {:message, CucumberMessages.GherkinDocument.Feature.Step}},
tags: {2, :unpacked, {:message, CucumberMessages.GherkinDocument.Feature.Tag}}
}
end
@spec required_fields() :: []
def(required_fields()) do
[]
end
@spec unknown_fields(struct) :: [{non_neg_integer, Protox.Types.tag(), binary}]
def(unknown_fields(msg)) do
msg.__uf__()
end
@spec unknown_fields_name() :: :__uf__
def(unknown_fields_name()) do
:__uf__
end
@spec clear_unknown_fields(struct) :: struct
def(clear_unknown_fields(msg)) do
struct!(msg, [{unknown_fields_name(), []}])
end
@spec syntax() :: atom
def(syntax()) do
:proto3
end
[
@spec(
default(atom) :: {:ok, boolean | integer | String.t() | binary | float} | {:error, atom}
),
[
def(default(:location)) do
{:ok, nil}
end,
def(default(:tags)) do
{:error, :no_default_value}
end,
def(default(:keyword)) do
{:ok, ""}
end,
def(default(:name)) do
{:ok, ""}
end,
def(default(:description)) do
{:ok, ""}
end,
def(default(:steps)) do
{:error, :no_default_value}
end,
def(default(:examples)) do
{:error, :no_default_value}
end,
def(default(:id)) do
{:ok, ""}
end
],
def(default(_)) do
{:error, :no_such_field}
end
]
)
[]
end,
defmodule(CucumberMessages.Meta.CI.Git) do
@moduledoc false
(
defstruct(remote: "", revision: "", branch: "", tag: "", __uf__: [])
(
@spec encode(struct) :: {:ok, iodata} | {:error, any}
def(encode(msg)) do
try do
{:ok, encode!(msg)}
rescue
e ->
{:error, e}
end
end
@spec encode!(struct) :: iodata | no_return
def(encode!(msg)) do
[]
|> encode_remote(msg)
|> encode_revision(msg)
|> encode_branch(msg)
|> encode_tag(msg)
|> encode_unknown_fields(msg)
end
[]
[
defp(encode_remote(acc, msg)) do
field_value = msg.remote()
if(field_value == "") do
acc
else
[acc, "\n", Protox.Encode.encode_string(field_value)]
end
end,
defp(encode_revision(acc, msg)) do
field_value = msg.revision()
if(field_value == "") do
acc
else
[acc, <<18>>, Protox.Encode.encode_string(field_value)]
end
end,
defp(encode_branch(acc, msg)) do
field_value = msg.branch()
if(field_value == "") do
acc
else
[acc, <<26>>, Protox.Encode.encode_string(field_value)]
end
end,
defp(encode_tag(acc, msg)) do
field_value = msg.tag()
if(field_value == "") do
acc
else
[acc, "\"", Protox.Encode.encode_string(field_value)]
end
end
]
defp(encode_unknown_fields(acc, msg)) do
Enum.reduce(msg.__struct__.unknown_fields(msg), acc, fn {tag, wire_type, bytes}, acc ->
case(wire_type) do
0 ->
[acc, Protox.Encode.make_key_bytes(tag, :int32), bytes]
1 ->
[acc, Protox.Encode.make_key_bytes(tag, :double), bytes]
2 ->
len_bytes = bytes |> byte_size() |> Protox.Varint.encode()
[acc, Protox.Encode.make_key_bytes(tag, :packed), len_bytes, bytes]
5 ->
[acc, Protox.Encode.make_key_bytes(tag, :float), bytes]
end
end)
end
)
(
@spec decode(binary) :: {:ok, struct} | {:error, any}
def(decode(bytes)) do
try do
{:ok, decode!(bytes)}
rescue
Protox.IllegalTagError ->
{:error, :illegal_tag}
e in Protox.RequiredFieldsError ->
{:error, {:missing_fields, e.missing_fields}}
e in Protox.DecodingError ->
{:error, {e.reason, e.binary}}
e ->
{:error, e}
end
end
(
@spec decode!(binary) :: struct | no_return
def(decode!(bytes)) do
parse_key_value(bytes, struct(CucumberMessages.Meta.CI.Git))
end
)
(
@spec parse_key_value(binary, struct) :: struct
defp(parse_key_value(<<>>, msg)) do
msg
end
defp(parse_key_value(bytes, msg)) do
{field, rest} =
case(Protox.Decode.parse_key(bytes)) do
{0, _, _} ->
raise(%Protox.IllegalTagError{})
{1, _, bytes} ->
{len, bytes} = Protox.Varint.decode(bytes)
<<delimited::binary-size(len), rest::binary>> = bytes
value = delimited
field = {:remote, value}
{field, rest}
{2, _, bytes} ->
{len, bytes} = Protox.Varint.decode(bytes)
<<delimited::binary-size(len), rest::binary>> = bytes
value = delimited
field = {:revision, value}
{field, rest}
{3, _, bytes} ->
{len, bytes} = Protox.Varint.decode(bytes)
<<delimited::binary-size(len), rest::binary>> = bytes
value = delimited
field = {:branch, value}
{field, rest}
{4, _, bytes} ->
{len, bytes} = Protox.Varint.decode(bytes)
<<delimited::binary-size(len), rest::binary>> = bytes
value = delimited
field = {:tag, value}
{field, rest}
{tag, wire_type, rest} ->
{value, new_rest} = Protox.Decode.parse_unknown(tag, wire_type, rest)
field =
{msg.__struct__.unknown_fields_name,
[value | msg.__struct__.unknown_fields(msg)]}
{field, new_rest}
end
msg_updated = struct(msg, [field])
parse_key_value(rest, msg_updated)
end
)
[]
)
@spec defs() :: %{
required(non_neg_integer) => {atom, Protox.Types.kind(), Protox.Types.type()}
}
def(defs()) do
%{
1 => {:remote, {:default, ""}, :string},
2 => {:revision, {:default, ""}, :string},
3 => {:branch, {:default, ""}, :string},
4 => {:tag, {:default, ""}, :string}
}
end
@spec defs_by_name() :: %{
required(atom) => {non_neg_integer, Protox.Types.kind(), Protox.Types.type()}
}
def(defs_by_name()) do
%{
branch: {3, {:default, ""}, :string},
remote: {1, {:default, ""}, :string},
revision: {2, {:default, ""}, :string},
tag: {4, {:default, ""}, :string}
}
end
@spec required_fields() :: []
def(required_fields()) do
[]
end
@spec unknown_fields(struct) :: [{non_neg_integer, Protox.Types.tag(), binary}]
def(unknown_fields(msg)) do
msg.__uf__()
end
@spec unknown_fields_name() :: :__uf__
def(unknown_fields_name()) do
:__uf__
end
@spec clear_unknown_fields(struct) :: struct
def(clear_unknown_fields(msg)) do
struct!(msg, [{unknown_fields_name(), []}])
end
@spec syntax() :: atom
def(syntax()) do
:proto3
end
[
@spec(
default(atom) :: {:ok, boolean | integer | String.t() | binary | float} | {:error, atom}
),
[
def(default(:remote)) do
{:ok, ""}
end,
def(default(:revision)) do
{:ok, ""}
end,
def(default(:branch)) do
{:ok, ""}
end,
def(default(:tag)) do
{:ok, ""}
end
],
def(default(_)) do
{:error, :no_such_field}
end
]
)
[]
end,
defmodule(CucumberMessages.Source) do
@moduledoc false
(
defstruct(uri: "", data: "", media_type: "", __uf__: [])
(
@spec encode(struct) :: {:ok, iodata} | {:error, any}
def(encode(msg)) do
try do
{:ok, encode!(msg)}
rescue
e ->
{:error, e}
end
end
@spec encode!(struct) :: iodata | no_return
def(encode!(msg)) do
[]
|> encode_uri(msg)
|> encode_data(msg)
|> encode_media_type(msg)
|> encode_unknown_fields(msg)
end
[]
[
defp(encode_uri(acc, msg)) do
field_value = msg.uri()
if(field_value == "") do
acc
else
[acc, "\n", Protox.Encode.encode_string(field_value)]
end
end,
defp(encode_data(acc, msg)) do
field_value = msg.data()
if(field_value == "") do
acc
else
[acc, <<18>>, Protox.Encode.encode_string(field_value)]
end
end,
defp(encode_media_type(acc, msg)) do
field_value = msg.media_type()
if(field_value == "") do
acc
else
[acc, <<26>>, Protox.Encode.encode_string(field_value)]
end
end
]
defp(encode_unknown_fields(acc, msg)) do
Enum.reduce(msg.__struct__.unknown_fields(msg), acc, fn {tag, wire_type, bytes}, acc ->
case(wire_type) do
0 ->
[acc, Protox.Encode.make_key_bytes(tag, :int32), bytes]
1 ->
[acc, Protox.Encode.make_key_bytes(tag, :double), bytes]
2 ->
len_bytes = bytes |> byte_size() |> Protox.Varint.encode()
[acc, Protox.Encode.make_key_bytes(tag, :packed), len_bytes, bytes]
5 ->
[acc, Protox.Encode.make_key_bytes(tag, :float), bytes]
end
end)
end
)
(
@spec decode(binary) :: {:ok, struct} | {:error, any}
def(decode(bytes)) do
try do
{:ok, decode!(bytes)}
rescue
Protox.IllegalTagError ->
{:error, :illegal_tag}
e in Protox.RequiredFieldsError ->
{:error, {:missing_fields, e.missing_fields}}
e in Protox.DecodingError ->
{:error, {e.reason, e.binary}}
e ->
{:error, e}
end
end
(
@spec decode!(binary) :: struct | no_return
def(decode!(bytes)) do
parse_key_value(bytes, struct(CucumberMessages.Source))
end
)
(
@spec parse_key_value(binary, struct) :: struct
defp(parse_key_value(<<>>, msg)) do
msg
end
defp(parse_key_value(bytes, msg)) do
{field, rest} =
case(Protox.Decode.parse_key(bytes)) do
{0, _, _} ->
raise(%Protox.IllegalTagError{})
{1, _, bytes} ->
{len, bytes} = Protox.Varint.decode(bytes)
<<delimited::binary-size(len), rest::binary>> = bytes
value = delimited
field = {:uri, value}
{field, rest}
{2, _, bytes} ->
{len, bytes} = Protox.Varint.decode(bytes)
<<delimited::binary-size(len), rest::binary>> = bytes
value = delimited
field = {:data, value}
{field, rest}
{3, _, bytes} ->
{len, bytes} = Protox.Varint.decode(bytes)
<<delimited::binary-size(len), rest::binary>> = bytes
value = delimited
field = {:media_type, value}
{field, rest}
{tag, wire_type, rest} ->
{value, new_rest} = Protox.Decode.parse_unknown(tag, wire_type, rest)
field =
{msg.__struct__.unknown_fields_name,
[value | msg.__struct__.unknown_fields(msg)]}
{field, new_rest}
end
msg_updated = struct(msg, [field])
parse_key_value(rest, msg_updated)
end
)
[]
)
@spec defs() :: %{
required(non_neg_integer) => {atom, Protox.Types.kind(), Protox.Types.type()}
}
def(defs()) do
%{
1 => {:uri, {:default, ""}, :string},
2 => {:data, {:default, ""}, :string},
3 => {:media_type, {:default, ""}, :string}
}
end
@spec defs_by_name() :: %{
required(atom) => {non_neg_integer, Protox.Types.kind(), Protox.Types.type()}
}
def(defs_by_name()) do
%{
data: {2, {:default, ""}, :string},
media_type: {3, {:default, ""}, :string},
uri: {1, {:default, ""}, :string}
}
end
@spec required_fields() :: []
def(required_fields()) do
[]
end
@spec unknown_fields(struct) :: [{non_neg_integer, Protox.Types.tag(), binary}]
def(unknown_fields(msg)) do
msg.__uf__()
end
@spec unknown_fields_name() :: :__uf__
def(unknown_fields_name()) do
:__uf__
end
@spec clear_unknown_fields(struct) :: struct
def(clear_unknown_fields(msg)) do
struct!(msg, [{unknown_fields_name(), []}])
end
@spec syntax() :: atom
def(syntax()) do
:proto3
end
[
@spec(
default(atom) :: {:ok, boolean | integer | String.t() | binary | float} | {:error, atom}
),
[
def(default(:uri)) do
{:ok, ""}
end,
def(default(:data)) do
{:ok, ""}
end,
def(default(:media_type)) do
{:ok, ""}
end
],
def(default(_)) do
{:error, :no_such_field}
end
]
)
[]
end,
defmodule(CucumberMessages.GherkinDocument.Feature.Scenario.Examples) do
@moduledoc false
(
defstruct(
location: nil,
tags: [],
keyword: "",
name: "",
description: "",
table_header: nil,
table_body: [],
id: "",
__uf__: []
)
(
@spec encode(struct) :: {:ok, iodata} | {:error, any}
def(encode(msg)) do
try do
{:ok, encode!(msg)}
rescue
e ->
{:error, e}
end
end
@spec encode!(struct) :: iodata | no_return
def(encode!(msg)) do
[]
|> encode_location(msg)
|> encode_tags(msg)
|> encode_keyword(msg)
|> encode_name(msg)
|> encode_description(msg)
|> encode_table_header(msg)
|> encode_table_body(msg)
|> encode_id(msg)
|> encode_unknown_fields(msg)
end
[]
[
defp(encode_location(acc, msg)) do
field_value = msg.location()
if(field_value == nil) do
acc
else
[acc, "\n", Protox.Encode.encode_message(field_value)]
end
end,
defp(encode_tags(acc, msg)) do
case(msg.tags()) do
[] ->
acc
values ->
[
acc,
Enum.reduce(values, [], fn value, acc ->
[acc, <<18>>, Protox.Encode.encode_message(value)]
end)
]
end
end,
defp(encode_keyword(acc, msg)) do
field_value = msg.keyword()
if(field_value == "") do
acc
else
[acc, <<26>>, Protox.Encode.encode_string(field_value)]
end
end,
defp(encode_name(acc, msg)) do
field_value = msg.name()
if(field_value == "") do
acc
else
[acc, "\"", Protox.Encode.encode_string(field_value)]
end
end,
defp(encode_description(acc, msg)) do
field_value = msg.description()
if(field_value == "") do
acc
else
[acc, "*", Protox.Encode.encode_string(field_value)]
end
end,
defp(encode_table_header(acc, msg)) do
field_value = msg.table_header()
if(field_value == nil) do
acc
else
[acc, "2", Protox.Encode.encode_message(field_value)]
end
end,
defp(encode_table_body(acc, msg)) do
case(msg.table_body()) do
[] ->
acc
values ->
[
acc,
Enum.reduce(values, [], fn value, acc ->
[acc, ":", Protox.Encode.encode_message(value)]
end)
]
end
end,
defp(encode_id(acc, msg)) do
field_value = msg.id()
if(field_value == "") do
acc
else
[acc, "B", Protox.Encode.encode_string(field_value)]
end
end
]
defp(encode_unknown_fields(acc, msg)) do
Enum.reduce(msg.__struct__.unknown_fields(msg), acc, fn {tag, wire_type, bytes}, acc ->
case(wire_type) do
0 ->
[acc, Protox.Encode.make_key_bytes(tag, :int32), bytes]
1 ->
[acc, Protox.Encode.make_key_bytes(tag, :double), bytes]
2 ->
len_bytes = bytes |> byte_size() |> Protox.Varint.encode()
[acc, Protox.Encode.make_key_bytes(tag, :packed), len_bytes, bytes]
5 ->
[acc, Protox.Encode.make_key_bytes(tag, :float), bytes]
end
end)
end
)
(
@spec decode(binary) :: {:ok, struct} | {:error, any}
def(decode(bytes)) do
try do
{:ok, decode!(bytes)}
rescue
Protox.IllegalTagError ->
{:error, :illegal_tag}
e in Protox.RequiredFieldsError ->
{:error, {:missing_fields, e.missing_fields}}
e in Protox.DecodingError ->
{:error, {e.reason, e.binary}}
e ->
{:error, e}
end
end
(
@spec decode!(binary) :: struct | no_return
def(decode!(bytes)) do
parse_key_value(
bytes,
struct(CucumberMessages.GherkinDocument.Feature.Scenario.Examples)
)
end
)
(
@spec parse_key_value(binary, struct) :: struct
defp(parse_key_value(<<>>, msg)) do
msg
end
defp(parse_key_value(bytes, msg)) do
{field, rest} =
case(Protox.Decode.parse_key(bytes)) do
{0, _, _} ->
raise(%Protox.IllegalTagError{})
{1, _, bytes} ->
{len, bytes} = Protox.Varint.decode(bytes)
<<delimited::binary-size(len), rest::binary>> = bytes
value = CucumberMessages.Location.decode!(delimited)
field = {:location, Protox.Message.merge(msg.location(), value)}
{field, rest}
{2, _, bytes} ->
{len, bytes} = Protox.Varint.decode(bytes)
<<delimited::binary-size(len), rest::binary>> = bytes
value = CucumberMessages.GherkinDocument.Feature.Tag.decode!(delimited)
field = {:tags, msg.tags() ++ List.wrap(value)}
{field, rest}
{3, _, bytes} ->
{len, bytes} = Protox.Varint.decode(bytes)
<<delimited::binary-size(len), rest::binary>> = bytes
value = delimited
field = {:keyword, value}
{field, rest}
{4, _, bytes} ->
{len, bytes} = Protox.Varint.decode(bytes)
<<delimited::binary-size(len), rest::binary>> = bytes
value = delimited
field = {:name, value}
{field, rest}
{5, _, bytes} ->
{len, bytes} = Protox.Varint.decode(bytes)
<<delimited::binary-size(len), rest::binary>> = bytes
value = delimited
field = {:description, value}
{field, rest}
{6, _, bytes} ->
{len, bytes} = Protox.Varint.decode(bytes)
<<delimited::binary-size(len), rest::binary>> = bytes
value = CucumberMessages.GherkinDocument.Feature.TableRow.decode!(delimited)
field = {:table_header, Protox.Message.merge(msg.table_header(), value)}
{field, rest}
{7, _, bytes} ->
{len, bytes} = Protox.Varint.decode(bytes)
<<delimited::binary-size(len), rest::binary>> = bytes
value = CucumberMessages.GherkinDocument.Feature.TableRow.decode!(delimited)
field = {:table_body, msg.table_body() ++ List.wrap(value)}
{field, rest}
{8, _, bytes} ->
{len, bytes} = Protox.Varint.decode(bytes)
<<delimited::binary-size(len), rest::binary>> = bytes
value = delimited
field = {:id, value}
{field, rest}
{tag, wire_type, rest} ->
{value, new_rest} = Protox.Decode.parse_unknown(tag, wire_type, rest)
field =
{msg.__struct__.unknown_fields_name,
[value | msg.__struct__.unknown_fields(msg)]}
{field, new_rest}
end
msg_updated = struct(msg, [field])
parse_key_value(rest, msg_updated)
end
)
[]
)
@spec defs() :: %{
required(non_neg_integer) => {atom, Protox.Types.kind(), Protox.Types.type()}
}
def(defs()) do
%{
1 => {:location, {:default, nil}, {:message, CucumberMessages.Location}},
2 => {:tags, :unpacked, {:message, CucumberMessages.GherkinDocument.Feature.Tag}},
3 => {:keyword, {:default, ""}, :string},
4 => {:name, {:default, ""}, :string},
5 => {:description, {:default, ""}, :string},
6 =>
{:table_header, {:default, nil},
{:message, CucumberMessages.GherkinDocument.Feature.TableRow}},
7 =>
{:table_body, :unpacked,
{:message, CucumberMessages.GherkinDocument.Feature.TableRow}},
8 => {:id, {:default, ""}, :string}
}
end
@spec defs_by_name() :: %{
required(atom) => {non_neg_integer, Protox.Types.kind(), Protox.Types.type()}
}
def(defs_by_name()) do
%{
description: {5, {:default, ""}, :string},
id: {8, {:default, ""}, :string},
keyword: {3, {:default, ""}, :string},
location: {1, {:default, nil}, {:message, CucumberMessages.Location}},
name: {4, {:default, ""}, :string},
table_body:
{7, :unpacked, {:message, CucumberMessages.GherkinDocument.Feature.TableRow}},
table_header:
{6, {:default, nil}, {:message, CucumberMessages.GherkinDocument.Feature.TableRow}},
tags: {2, :unpacked, {:message, CucumberMessages.GherkinDocument.Feature.Tag}}
}
end
@spec required_fields() :: []
def(required_fields()) do
[]
end
@spec unknown_fields(struct) :: [{non_neg_integer, Protox.Types.tag(), binary}]
def(unknown_fields(msg)) do
msg.__uf__()
end
@spec unknown_fields_name() :: :__uf__
def(unknown_fields_name()) do
:__uf__
end
@spec clear_unknown_fields(struct) :: struct
def(clear_unknown_fields(msg)) do
struct!(msg, [{unknown_fields_name(), []}])
end
@spec syntax() :: atom
def(syntax()) do
:proto3
end
[
@spec(
default(atom) :: {:ok, boolean | integer | String.t() | binary | float} | {:error, atom}
),
[
def(default(:location)) do
{:ok, nil}
end,
def(default(:tags)) do
{:error, :no_default_value}
end,
def(default(:keyword)) do
{:ok, ""}
end,
def(default(:name)) do
{:ok, ""}
end,
def(default(:description)) do
{:ok, ""}
end,
def(default(:table_header)) do
{:ok, nil}
end,
def(default(:table_body)) do
{:error, :no_default_value}
end,
def(default(:id)) do
{:ok, ""}
end
],
def(default(_)) do
{:error, :no_such_field}
end
]
)
[]
end,
defmodule(CucumberMessages.TestCase.TestStep.StepMatchArgumentsList.StepMatchArgument.Group) do
@moduledoc false
(
defstruct(start: 0, value: "", children: [], __uf__: [])
(
@spec encode(struct) :: {:ok, iodata} | {:error, any}
def(encode(msg)) do
try do
{:ok, encode!(msg)}
rescue
e ->
{:error, e}
end
end
@spec encode!(struct) :: iodata | no_return
def(encode!(msg)) do
[]
|> encode_start(msg)
|> encode_value(msg)
|> encode_children(msg)
|> encode_unknown_fields(msg)
end
[]
[
defp(encode_start(acc, msg)) do
field_value = msg.start()
if(field_value == 0) do
acc
else
[acc, "\b", Protox.Encode.encode_uint32(field_value)]
end
end,
defp(encode_value(acc, msg)) do
field_value = msg.value()
if(field_value == "") do
acc
else
[acc, <<18>>, Protox.Encode.encode_string(field_value)]
end
end,
defp(encode_children(acc, msg)) do
case(msg.children()) do
[] ->
acc
values ->
[
acc,
Enum.reduce(values, [], fn value, acc ->
[acc, <<26>>, Protox.Encode.encode_message(value)]
end)
]
end
end
]
defp(encode_unknown_fields(acc, msg)) do
Enum.reduce(msg.__struct__.unknown_fields(msg), acc, fn {tag, wire_type, bytes}, acc ->
case(wire_type) do
0 ->
[acc, Protox.Encode.make_key_bytes(tag, :int32), bytes]
1 ->
[acc, Protox.Encode.make_key_bytes(tag, :double), bytes]
2 ->
len_bytes = bytes |> byte_size() |> Protox.Varint.encode()
[acc, Protox.Encode.make_key_bytes(tag, :packed), len_bytes, bytes]
5 ->
[acc, Protox.Encode.make_key_bytes(tag, :float), bytes]
end
end)
end
)
(
@spec decode(binary) :: {:ok, struct} | {:error, any}
def(decode(bytes)) do
try do
{:ok, decode!(bytes)}
rescue
Protox.IllegalTagError ->
{:error, :illegal_tag}
e in Protox.RequiredFieldsError ->
{:error, {:missing_fields, e.missing_fields}}
e in Protox.DecodingError ->
{:error, {e.reason, e.binary}}
e ->
{:error, e}
end
end
(
@spec decode!(binary) :: struct | no_return
def(decode!(bytes)) do
parse_key_value(
bytes,
struct(
CucumberMessages.TestCase.TestStep.StepMatchArgumentsList.StepMatchArgument.Group
)
)
end
)
(
@spec parse_key_value(binary, struct) :: struct
defp(parse_key_value(<<>>, msg)) do
msg
end
defp(parse_key_value(bytes, msg)) do
{field, rest} =
case(Protox.Decode.parse_key(bytes)) do
{0, _, _} ->
raise(%Protox.IllegalTagError{})
{1, _, bytes} ->
{value, rest} = Protox.Decode.parse_uint32(bytes)
field = {:start, value}
{field, rest}
{2, _, bytes} ->
{len, bytes} = Protox.Varint.decode(bytes)
<<delimited::binary-size(len), rest::binary>> = bytes
value = delimited
field = {:value, value}
{field, rest}
{3, _, bytes} ->
{len, bytes} = Protox.Varint.decode(bytes)
<<delimited::binary-size(len), rest::binary>> = bytes
value =
CucumberMessages.TestCase.TestStep.StepMatchArgumentsList.StepMatchArgument.Group.decode!(
delimited
)
field = {:children, msg.children() ++ List.wrap(value)}
{field, rest}
{tag, wire_type, rest} ->
{value, new_rest} = Protox.Decode.parse_unknown(tag, wire_type, rest)
field =
{msg.__struct__.unknown_fields_name,
[value | msg.__struct__.unknown_fields(msg)]}
{field, new_rest}
end
msg_updated = struct(msg, [field])
parse_key_value(rest, msg_updated)
end
)
[]
)
@spec defs() :: %{
required(non_neg_integer) => {atom, Protox.Types.kind(), Protox.Types.type()}
}
def(defs()) do
%{
1 => {:start, {:default, 0}, :uint32},
2 => {:value, {:default, ""}, :string},
3 =>
{:children, :unpacked,
{:message,
CucumberMessages.TestCase.TestStep.StepMatchArgumentsList.StepMatchArgument.Group}}
}
end
@spec defs_by_name() :: %{
required(atom) => {non_neg_integer, Protox.Types.kind(), Protox.Types.type()}
}
def(defs_by_name()) do
%{
children:
{3, :unpacked,
{:message,
CucumberMessages.TestCase.TestStep.StepMatchArgumentsList.StepMatchArgument.Group}},
start: {1, {:default, 0}, :uint32},
value: {2, {:default, ""}, :string}
}
end
@spec required_fields() :: []
def(required_fields()) do
[]
end
@spec unknown_fields(struct) :: [{non_neg_integer, Protox.Types.tag(), binary}]
def(unknown_fields(msg)) do
msg.__uf__()
end
@spec unknown_fields_name() :: :__uf__
def(unknown_fields_name()) do
:__uf__
end
@spec clear_unknown_fields(struct) :: struct
def(clear_unknown_fields(msg)) do
struct!(msg, [{unknown_fields_name(), []}])
end
@spec syntax() :: atom
def(syntax()) do
:proto3
end
[
@spec(
default(atom) :: {:ok, boolean | integer | String.t() | binary | float} | {:error, atom}
),
[
def(default(:start)) do
{:ok, 0}
end,
def(default(:value)) do
{:ok, ""}
end,
def(default(:children)) do
{:error, :no_default_value}
end
],
def(default(_)) do
{:error, :no_such_field}
end
]
)
[]
end,
defmodule(CucumberMessages.PickleStepArgument.PickleTable.PickleTableRow) do
@moduledoc false
(
defstruct(cells: [], __uf__: [])
(
@spec encode(struct) :: {:ok, iodata} | {:error, any}
def(encode(msg)) do
try do
{:ok, encode!(msg)}
rescue
e ->
{:error, e}
end
end
@spec encode!(struct) :: iodata | no_return
def(encode!(msg)) do
[] |> encode_cells(msg) |> encode_unknown_fields(msg)
end
[]
[
defp(encode_cells(acc, msg)) do
case(msg.cells()) do
[] ->
acc
values ->
[
acc,
Enum.reduce(values, [], fn value, acc ->
[acc, "\n", Protox.Encode.encode_message(value)]
end)
]
end
end
]
defp(encode_unknown_fields(acc, msg)) do
Enum.reduce(msg.__struct__.unknown_fields(msg), acc, fn {tag, wire_type, bytes}, acc ->
case(wire_type) do
0 ->
[acc, Protox.Encode.make_key_bytes(tag, :int32), bytes]
1 ->
[acc, Protox.Encode.make_key_bytes(tag, :double), bytes]
2 ->
len_bytes = bytes |> byte_size() |> Protox.Varint.encode()
[acc, Protox.Encode.make_key_bytes(tag, :packed), len_bytes, bytes]
5 ->
[acc, Protox.Encode.make_key_bytes(tag, :float), bytes]
end
end)
end
)
(
@spec decode(binary) :: {:ok, struct} | {:error, any}
def(decode(bytes)) do
try do
{:ok, decode!(bytes)}
rescue
Protox.IllegalTagError ->
{:error, :illegal_tag}
e in Protox.RequiredFieldsError ->
{:error, {:missing_fields, e.missing_fields}}
e in Protox.DecodingError ->
{:error, {e.reason, e.binary}}
e ->
{:error, e}
end
end
(
@spec decode!(binary) :: struct | no_return
def(decode!(bytes)) do
parse_key_value(
bytes,
struct(CucumberMessages.PickleStepArgument.PickleTable.PickleTableRow)
)
end
)
(
@spec parse_key_value(binary, struct) :: struct
defp(parse_key_value(<<>>, msg)) do
msg
end
defp(parse_key_value(bytes, msg)) do
{field, rest} =
case(Protox.Decode.parse_key(bytes)) do
{0, _, _} ->
raise(%Protox.IllegalTagError{})
{1, _, bytes} ->
{len, bytes} = Protox.Varint.decode(bytes)
<<delimited::binary-size(len), rest::binary>> = bytes
value =
CucumberMessages.PickleStepArgument.PickleTable.PickleTableRow.PickleTableCell.decode!(
delimited
)
field = {:cells, msg.cells() ++ List.wrap(value)}
{field, rest}
{tag, wire_type, rest} ->
{value, new_rest} = Protox.Decode.parse_unknown(tag, wire_type, rest)
field =
{msg.__struct__.unknown_fields_name,
[value | msg.__struct__.unknown_fields(msg)]}
{field, new_rest}
end
msg_updated = struct(msg, [field])
parse_key_value(rest, msg_updated)
end
)
[]
)
@spec defs() :: %{
required(non_neg_integer) => {atom, Protox.Types.kind(), Protox.Types.type()}
}
def(defs()) do
%{
1 =>
{:cells, :unpacked,
{:message,
CucumberMessages.PickleStepArgument.PickleTable.PickleTableRow.PickleTableCell}}
}
end
@spec defs_by_name() :: %{
required(atom) => {non_neg_integer, Protox.Types.kind(), Protox.Types.type()}
}
def(defs_by_name()) do
%{
cells:
{1, :unpacked,
{:message,
CucumberMessages.PickleStepArgument.PickleTable.PickleTableRow.PickleTableCell}}
}
end
@spec required_fields() :: []
def(required_fields()) do
[]
end
@spec unknown_fields(struct) :: [{non_neg_integer, Protox.Types.tag(), binary}]
def(unknown_fields(msg)) do
msg.__uf__()
end
@spec unknown_fields_name() :: :__uf__
def(unknown_fields_name()) do
:__uf__
end
@spec clear_unknown_fields(struct) :: struct
def(clear_unknown_fields(msg)) do
struct!(msg, [{unknown_fields_name(), []}])
end
@spec syntax() :: atom
def(syntax()) do
:proto3
end
[
@spec(
default(atom) :: {:ok, boolean | integer | String.t() | binary | float} | {:error, atom}
),
[
def(default(:cells)) do
{:error, :no_default_value}
end
],
def(default(_)) do
{:error, :no_such_field}
end
]
)
[]
end,
defmodule(CucumberMessages.TestRunFinished) do
@moduledoc false
(
defstruct(success: false, timestamp: nil, message: "", __uf__: [])
(
@spec encode(struct) :: {:ok, iodata} | {:error, any}
def(encode(msg)) do
try do
{:ok, encode!(msg)}
rescue
e ->
{:error, e}
end
end
@spec encode!(struct) :: iodata | no_return
def(encode!(msg)) do
[]
|> encode_success(msg)
|> encode_timestamp(msg)
|> encode_message(msg)
|> encode_unknown_fields(msg)
end
[]
[
defp(encode_success(acc, msg)) do
field_value = msg.success()
if(field_value == false) do
acc
else
[acc, "\b", Protox.Encode.encode_bool(field_value)]
end
end,
defp(encode_timestamp(acc, msg)) do
field_value = msg.timestamp()
if(field_value == nil) do
acc
else
[acc, <<18>>, Protox.Encode.encode_message(field_value)]
end
end,
defp(encode_message(acc, msg)) do
field_value = msg.message()
if(field_value == "") do
acc
else
[acc, <<26>>, Protox.Encode.encode_string(field_value)]
end
end
]
defp(encode_unknown_fields(acc, msg)) do
Enum.reduce(msg.__struct__.unknown_fields(msg), acc, fn {tag, wire_type, bytes}, acc ->
case(wire_type) do
0 ->
[acc, Protox.Encode.make_key_bytes(tag, :int32), bytes]
1 ->
[acc, Protox.Encode.make_key_bytes(tag, :double), bytes]
2 ->
len_bytes = bytes |> byte_size() |> Protox.Varint.encode()
[acc, Protox.Encode.make_key_bytes(tag, :packed), len_bytes, bytes]
5 ->
[acc, Protox.Encode.make_key_bytes(tag, :float), bytes]
end
end)
end
)
(
@spec decode(binary) :: {:ok, struct} | {:error, any}
def(decode(bytes)) do
try do
{:ok, decode!(bytes)}
rescue
Protox.IllegalTagError ->
{:error, :illegal_tag}
e in Protox.RequiredFieldsError ->
{:error, {:missing_fields, e.missing_fields}}
e in Protox.DecodingError ->
{:error, {e.reason, e.binary}}
e ->
{:error, e}
end
end
(
@spec decode!(binary) :: struct | no_return
def(decode!(bytes)) do
parse_key_value(bytes, struct(CucumberMessages.TestRunFinished))
end
)
(
@spec parse_key_value(binary, struct) :: struct
defp(parse_key_value(<<>>, msg)) do
msg
end
defp(parse_key_value(bytes, msg)) do
{field, rest} =
case(Protox.Decode.parse_key(bytes)) do
{0, _, _} ->
raise(%Protox.IllegalTagError{})
{1, _, bytes} ->
{value, rest} = Protox.Decode.parse_bool(bytes)
field = {:success, value}
{field, rest}
{2, _, bytes} ->
{len, bytes} = Protox.Varint.decode(bytes)
<<delimited::binary-size(len), rest::binary>> = bytes
value = CucumberMessages.Timestamp.decode!(delimited)
field = {:timestamp, Protox.Message.merge(msg.timestamp(), value)}
{field, rest}
{3, _, bytes} ->
{len, bytes} = Protox.Varint.decode(bytes)
<<delimited::binary-size(len), rest::binary>> = bytes
value = delimited
field = {:message, value}
{field, rest}
{tag, wire_type, rest} ->
{value, new_rest} = Protox.Decode.parse_unknown(tag, wire_type, rest)
field =
{msg.__struct__.unknown_fields_name,
[value | msg.__struct__.unknown_fields(msg)]}
{field, new_rest}
end
msg_updated = struct(msg, [field])
parse_key_value(rest, msg_updated)
end
)
[]
)
@spec defs() :: %{
required(non_neg_integer) => {atom, Protox.Types.kind(), Protox.Types.type()}
}
def(defs()) do
%{
1 => {:success, {:default, false}, :bool},
2 => {:timestamp, {:default, nil}, {:message, CucumberMessages.Timestamp}},
3 => {:message, {:default, ""}, :string}
}
end
@spec defs_by_name() :: %{
required(atom) => {non_neg_integer, Protox.Types.kind(), Protox.Types.type()}
}
def(defs_by_name()) do
%{
message: {3, {:default, ""}, :string},
success: {1, {:default, false}, :bool},
timestamp: {2, {:default, nil}, {:message, CucumberMessages.Timestamp}}
}
end
@spec required_fields() :: []
def(required_fields()) do
[]
end
@spec unknown_fields(struct) :: [{non_neg_integer, Protox.Types.tag(), binary}]
def(unknown_fields(msg)) do
msg.__uf__()
end
@spec unknown_fields_name() :: :__uf__
def(unknown_fields_name()) do
:__uf__
end
@spec clear_unknown_fields(struct) :: struct
def(clear_unknown_fields(msg)) do
struct!(msg, [{unknown_fields_name(), []}])
end
@spec syntax() :: atom
def(syntax()) do
:proto3
end
[
@spec(
default(atom) :: {:ok, boolean | integer | String.t() | binary | float} | {:error, atom}
),
[
def(default(:success)) do
{:ok, false}
end,
def(default(:timestamp)) do
{:ok, nil}
end,
def(default(:message)) do
{:ok, ""}
end
],
def(default(_)) do
{:error, :no_such_field}
end
]
)
[]
end,
defmodule(CucumberMessages.TestRunStarted) do
@moduledoc false
(
defstruct(timestamp: nil, __uf__: [])
(
@spec encode(struct) :: {:ok, iodata} | {:error, any}
def(encode(msg)) do
try do
{:ok, encode!(msg)}
rescue
e ->
{:error, e}
end
end
@spec encode!(struct) :: iodata | no_return
def(encode!(msg)) do
[] |> encode_timestamp(msg) |> encode_unknown_fields(msg)
end
[]
[
defp(encode_timestamp(acc, msg)) do
field_value = msg.timestamp()
if(field_value == nil) do
acc
else
[acc, "\n", Protox.Encode.encode_message(field_value)]
end
end
]
defp(encode_unknown_fields(acc, msg)) do
Enum.reduce(msg.__struct__.unknown_fields(msg), acc, fn {tag, wire_type, bytes}, acc ->
case(wire_type) do
0 ->
[acc, Protox.Encode.make_key_bytes(tag, :int32), bytes]
1 ->
[acc, Protox.Encode.make_key_bytes(tag, :double), bytes]
2 ->
len_bytes = bytes |> byte_size() |> Protox.Varint.encode()
[acc, Protox.Encode.make_key_bytes(tag, :packed), len_bytes, bytes]
5 ->
[acc, Protox.Encode.make_key_bytes(tag, :float), bytes]
end
end)
end
)
(
@spec decode(binary) :: {:ok, struct} | {:error, any}
def(decode(bytes)) do
try do
{:ok, decode!(bytes)}
rescue
Protox.IllegalTagError ->
{:error, :illegal_tag}
e in Protox.RequiredFieldsError ->
{:error, {:missing_fields, e.missing_fields}}
e in Protox.DecodingError ->
{:error, {e.reason, e.binary}}
e ->
{:error, e}
end
end
(
@spec decode!(binary) :: struct | no_return
def(decode!(bytes)) do
parse_key_value(bytes, struct(CucumberMessages.TestRunStarted))
end
)
(
@spec parse_key_value(binary, struct) :: struct
defp(parse_key_value(<<>>, msg)) do
msg
end
defp(parse_key_value(bytes, msg)) do
{field, rest} =
case(Protox.Decode.parse_key(bytes)) do
{0, _, _} ->
raise(%Protox.IllegalTagError{})
{1, _, bytes} ->
{len, bytes} = Protox.Varint.decode(bytes)
<<delimited::binary-size(len), rest::binary>> = bytes
value = CucumberMessages.Timestamp.decode!(delimited)
field = {:timestamp, Protox.Message.merge(msg.timestamp(), value)}
{field, rest}
{tag, wire_type, rest} ->
{value, new_rest} = Protox.Decode.parse_unknown(tag, wire_type, rest)
field =
{msg.__struct__.unknown_fields_name,
[value | msg.__struct__.unknown_fields(msg)]}
{field, new_rest}
end
msg_updated = struct(msg, [field])
parse_key_value(rest, msg_updated)
end
)
[]
)
@spec defs() :: %{
required(non_neg_integer) => {atom, Protox.Types.kind(), Protox.Types.type()}
}
def(defs()) do
%{1 => {:timestamp, {:default, nil}, {:message, CucumberMessages.Timestamp}}}
end
@spec defs_by_name() :: %{
required(atom) => {non_neg_integer, Protox.Types.kind(), Protox.Types.type()}
}
def(defs_by_name()) do
%{timestamp: {1, {:default, nil}, {:message, CucumberMessages.Timestamp}}}
end
@spec required_fields() :: []
def(required_fields()) do
[]
end
@spec unknown_fields(struct) :: [{non_neg_integer, Protox.Types.tag(), binary}]
def(unknown_fields(msg)) do
msg.__uf__()
end
@spec unknown_fields_name() :: :__uf__
def(unknown_fields_name()) do
:__uf__
end
@spec clear_unknown_fields(struct) :: struct
def(clear_unknown_fields(msg)) do
struct!(msg, [{unknown_fields_name(), []}])
end
@spec syntax() :: atom
def(syntax()) do
:proto3
end
[
@spec(
default(atom) :: {:ok, boolean | integer | String.t() | binary | float} | {:error, atom}
),
[
def(default(:timestamp)) do
{:ok, nil}
end
],
def(default(_)) do
{:error, :no_such_field}
end
]
)
[]
end,
defmodule(CucumberMessages.GherkinDocument.Feature.TableRow.TableCell) do
@moduledoc false
(
defstruct(location: nil, value: "", __uf__: [])
(
@spec encode(struct) :: {:ok, iodata} | {:error, any}
def(encode(msg)) do
try do
{:ok, encode!(msg)}
rescue
e ->
{:error, e}
end
end
@spec encode!(struct) :: iodata | no_return
def(encode!(msg)) do
[] |> encode_location(msg) |> encode_value(msg) |> encode_unknown_fields(msg)
end
[]
[
defp(encode_location(acc, msg)) do
field_value = msg.location()
if(field_value == nil) do
acc
else
[acc, "\n", Protox.Encode.encode_message(field_value)]
end
end,
defp(encode_value(acc, msg)) do
field_value = msg.value()
if(field_value == "") do
acc
else
[acc, <<18>>, Protox.Encode.encode_string(field_value)]
end
end
]
defp(encode_unknown_fields(acc, msg)) do
Enum.reduce(msg.__struct__.unknown_fields(msg), acc, fn {tag, wire_type, bytes}, acc ->
case(wire_type) do
0 ->
[acc, Protox.Encode.make_key_bytes(tag, :int32), bytes]
1 ->
[acc, Protox.Encode.make_key_bytes(tag, :double), bytes]
2 ->
len_bytes = bytes |> byte_size() |> Protox.Varint.encode()
[acc, Protox.Encode.make_key_bytes(tag, :packed), len_bytes, bytes]
5 ->
[acc, Protox.Encode.make_key_bytes(tag, :float), bytes]
end
end)
end
)
(
@spec decode(binary) :: {:ok, struct} | {:error, any}
def(decode(bytes)) do
try do
{:ok, decode!(bytes)}
rescue
Protox.IllegalTagError ->
{:error, :illegal_tag}
e in Protox.RequiredFieldsError ->
{:error, {:missing_fields, e.missing_fields}}
e in Protox.DecodingError ->
{:error, {e.reason, e.binary}}
e ->
{:error, e}
end
end
(
@spec decode!(binary) :: struct | no_return
def(decode!(bytes)) do
parse_key_value(
bytes,
struct(CucumberMessages.GherkinDocument.Feature.TableRow.TableCell)
)
end
)
(
@spec parse_key_value(binary, struct) :: struct
defp(parse_key_value(<<>>, msg)) do
msg
end
defp(parse_key_value(bytes, msg)) do
{field, rest} =
case(Protox.Decode.parse_key(bytes)) do
{0, _, _} ->
raise(%Protox.IllegalTagError{})
{1, _, bytes} ->
{len, bytes} = Protox.Varint.decode(bytes)
<<delimited::binary-size(len), rest::binary>> = bytes
value = CucumberMessages.Location.decode!(delimited)
field = {:location, Protox.Message.merge(msg.location(), value)}
{field, rest}
{2, _, bytes} ->
{len, bytes} = Protox.Varint.decode(bytes)
<<delimited::binary-size(len), rest::binary>> = bytes
value = delimited
field = {:value, value}
{field, rest}
{tag, wire_type, rest} ->
{value, new_rest} = Protox.Decode.parse_unknown(tag, wire_type, rest)
field =
{msg.__struct__.unknown_fields_name,
[value | msg.__struct__.unknown_fields(msg)]}
{field, new_rest}
end
msg_updated = struct(msg, [field])
parse_key_value(rest, msg_updated)
end
)
[]
)
@spec defs() :: %{
required(non_neg_integer) => {atom, Protox.Types.kind(), Protox.Types.type()}
}
def(defs()) do
%{
1 => {:location, {:default, nil}, {:message, CucumberMessages.Location}},
2 => {:value, {:default, ""}, :string}
}
end
@spec defs_by_name() :: %{
required(atom) => {non_neg_integer, Protox.Types.kind(), Protox.Types.type()}
}
def(defs_by_name()) do
%{
location: {1, {:default, nil}, {:message, CucumberMessages.Location}},
value: {2, {:default, ""}, :string}
}
end
@spec required_fields() :: []
def(required_fields()) do
[]
end
@spec unknown_fields(struct) :: [{non_neg_integer, Protox.Types.tag(), binary}]
def(unknown_fields(msg)) do
msg.__uf__()
end
@spec unknown_fields_name() :: :__uf__
def(unknown_fields_name()) do
:__uf__
end
@spec clear_unknown_fields(struct) :: struct
def(clear_unknown_fields(msg)) do
struct!(msg, [{unknown_fields_name(), []}])
end
@spec syntax() :: atom
def(syntax()) do
:proto3
end
[
@spec(
default(atom) :: {:ok, boolean | integer | String.t() | binary | float} | {:error, atom}
),
[
def(default(:location)) do
{:ok, nil}
end,
def(default(:value)) do
{:ok, ""}
end
],
def(default(_)) do
{:error, :no_such_field}
end
]
)
[]
end,
defmodule(CucumberMessages.GherkinDocument.Feature.TableRow) do
@moduledoc false
(
defstruct(location: nil, cells: [], id: "", __uf__: [])
(
@spec encode(struct) :: {:ok, iodata} | {:error, any}
def(encode(msg)) do
try do
{:ok, encode!(msg)}
rescue
e ->
{:error, e}
end
end
@spec encode!(struct) :: iodata | no_return
def(encode!(msg)) do
[]
|> encode_location(msg)
|> encode_cells(msg)
|> encode_id(msg)
|> encode_unknown_fields(msg)
end
[]
[
defp(encode_location(acc, msg)) do
field_value = msg.location()
if(field_value == nil) do
acc
else
[acc, "\n", Protox.Encode.encode_message(field_value)]
end
end,
defp(encode_cells(acc, msg)) do
case(msg.cells()) do
[] ->
acc
values ->
[
acc,
Enum.reduce(values, [], fn value, acc ->
[acc, <<18>>, Protox.Encode.encode_message(value)]
end)
]
end
end,
defp(encode_id(acc, msg)) do
field_value = msg.id()
if(field_value == "") do
acc
else
[acc, <<26>>, Protox.Encode.encode_string(field_value)]
end
end
]
defp(encode_unknown_fields(acc, msg)) do
Enum.reduce(msg.__struct__.unknown_fields(msg), acc, fn {tag, wire_type, bytes}, acc ->
case(wire_type) do
0 ->
[acc, Protox.Encode.make_key_bytes(tag, :int32), bytes]
1 ->
[acc, Protox.Encode.make_key_bytes(tag, :double), bytes]
2 ->
len_bytes = bytes |> byte_size() |> Protox.Varint.encode()
[acc, Protox.Encode.make_key_bytes(tag, :packed), len_bytes, bytes]
5 ->
[acc, Protox.Encode.make_key_bytes(tag, :float), bytes]
end
end)
end
)
(
@spec decode(binary) :: {:ok, struct} | {:error, any}
def(decode(bytes)) do
try do
{:ok, decode!(bytes)}
rescue
Protox.IllegalTagError ->
{:error, :illegal_tag}
e in Protox.RequiredFieldsError ->
{:error, {:missing_fields, e.missing_fields}}
e in Protox.DecodingError ->
{:error, {e.reason, e.binary}}
e ->
{:error, e}
end
end
(
@spec decode!(binary) :: struct | no_return
def(decode!(bytes)) do
parse_key_value(bytes, struct(CucumberMessages.GherkinDocument.Feature.TableRow))
end
)
(
@spec parse_key_value(binary, struct) :: struct
defp(parse_key_value(<<>>, msg)) do
msg
end
defp(parse_key_value(bytes, msg)) do
{field, rest} =
case(Protox.Decode.parse_key(bytes)) do
{0, _, _} ->
raise(%Protox.IllegalTagError{})
{1, _, bytes} ->
{len, bytes} = Protox.Varint.decode(bytes)
<<delimited::binary-size(len), rest::binary>> = bytes
value = CucumberMessages.Location.decode!(delimited)
field = {:location, Protox.Message.merge(msg.location(), value)}
{field, rest}
{2, _, bytes} ->
{len, bytes} = Protox.Varint.decode(bytes)
<<delimited::binary-size(len), rest::binary>> = bytes
value =
CucumberMessages.GherkinDocument.Feature.TableRow.TableCell.decode!(delimited)
field = {:cells, msg.cells() ++ List.wrap(value)}
{field, rest}
{3, _, bytes} ->
{len, bytes} = Protox.Varint.decode(bytes)
<<delimited::binary-size(len), rest::binary>> = bytes
value = delimited
field = {:id, value}
{field, rest}
{tag, wire_type, rest} ->
{value, new_rest} = Protox.Decode.parse_unknown(tag, wire_type, rest)
field =
{msg.__struct__.unknown_fields_name,
[value | msg.__struct__.unknown_fields(msg)]}
{field, new_rest}
end
msg_updated = struct(msg, [field])
parse_key_value(rest, msg_updated)
end
)
[]
)
@spec defs() :: %{
required(non_neg_integer) => {atom, Protox.Types.kind(), Protox.Types.type()}
}
def(defs()) do
%{
1 => {:location, {:default, nil}, {:message, CucumberMessages.Location}},
2 =>
{:cells, :unpacked,
{:message, CucumberMessages.GherkinDocument.Feature.TableRow.TableCell}},
3 => {:id, {:default, ""}, :string}
}
end
@spec defs_by_name() :: %{
required(atom) => {non_neg_integer, Protox.Types.kind(), Protox.Types.type()}
}
def(defs_by_name()) do
%{
cells:
{2, :unpacked,
{:message, CucumberMessages.GherkinDocument.Feature.TableRow.TableCell}},
id: {3, {:default, ""}, :string},
location: {1, {:default, nil}, {:message, CucumberMessages.Location}}
}
end
@spec required_fields() :: []
def(required_fields()) do
[]
end
@spec unknown_fields(struct) :: [{non_neg_integer, Protox.Types.tag(), binary}]
def(unknown_fields(msg)) do
msg.__uf__()
end
@spec unknown_fields_name() :: :__uf__
def(unknown_fields_name()) do
:__uf__
end
@spec clear_unknown_fields(struct) :: struct
def(clear_unknown_fields(msg)) do
struct!(msg, [{unknown_fields_name(), []}])
end
@spec syntax() :: atom
def(syntax()) do
:proto3
end
[
@spec(
default(atom) :: {:ok, boolean | integer | String.t() | binary | float} | {:error, atom}
),
[
def(default(:location)) do
{:ok, nil}
end,
def(default(:cells)) do
{:error, :no_default_value}
end,
def(default(:id)) do
{:ok, ""}
end
],
def(default(_)) do
{:error, :no_such_field}
end
]
)
[]
end,
defmodule(CucumberMessages.TestStepFinished) do
@moduledoc false
(
defstruct(
test_step_result: nil,
timestamp: nil,
test_step_id: "",
test_case_started_id: "",
__uf__: []
)
(
@spec encode(struct) :: {:ok, iodata} | {:error, any}
def(encode(msg)) do
try do
{:ok, encode!(msg)}
rescue
e ->
{:error, e}
end
end
@spec encode!(struct) :: iodata | no_return
def(encode!(msg)) do
[]
|> encode_test_step_result(msg)
|> encode_timestamp(msg)
|> encode_test_step_id(msg)
|> encode_test_case_started_id(msg)
|> encode_unknown_fields(msg)
end
[]
[
defp(encode_test_step_result(acc, msg)) do
field_value = msg.test_step_result()
if(field_value == nil) do
acc
else
[acc, "\n", Protox.Encode.encode_message(field_value)]
end
end,
defp(encode_timestamp(acc, msg)) do
field_value = msg.timestamp()
if(field_value == nil) do
acc
else
[acc, <<18>>, Protox.Encode.encode_message(field_value)]
end
end,
defp(encode_test_step_id(acc, msg)) do
field_value = msg.test_step_id()
if(field_value == "") do
acc
else
[acc, <<26>>, Protox.Encode.encode_string(field_value)]
end
end,
defp(encode_test_case_started_id(acc, msg)) do
field_value = msg.test_case_started_id()
if(field_value == "") do
acc
else
[acc, "\"", Protox.Encode.encode_string(field_value)]
end
end
]
defp(encode_unknown_fields(acc, msg)) do
Enum.reduce(msg.__struct__.unknown_fields(msg), acc, fn {tag, wire_type, bytes}, acc ->
case(wire_type) do
0 ->
[acc, Protox.Encode.make_key_bytes(tag, :int32), bytes]
1 ->
[acc, Protox.Encode.make_key_bytes(tag, :double), bytes]
2 ->
len_bytes = bytes |> byte_size() |> Protox.Varint.encode()
[acc, Protox.Encode.make_key_bytes(tag, :packed), len_bytes, bytes]
5 ->
[acc, Protox.Encode.make_key_bytes(tag, :float), bytes]
end
end)
end
)
(
@spec decode(binary) :: {:ok, struct} | {:error, any}
def(decode(bytes)) do
try do
{:ok, decode!(bytes)}
rescue
Protox.IllegalTagError ->
{:error, :illegal_tag}
e in Protox.RequiredFieldsError ->
{:error, {:missing_fields, e.missing_fields}}
e in Protox.DecodingError ->
{:error, {e.reason, e.binary}}
e ->
{:error, e}
end
end
(
@spec decode!(binary) :: struct | no_return
def(decode!(bytes)) do
parse_key_value(bytes, struct(CucumberMessages.TestStepFinished))
end
)
(
@spec parse_key_value(binary, struct) :: struct
defp(parse_key_value(<<>>, msg)) do
msg
end
defp(parse_key_value(bytes, msg)) do
{field, rest} =
case(Protox.Decode.parse_key(bytes)) do
{0, _, _} ->
raise(%Protox.IllegalTagError{})
{1, _, bytes} ->
{len, bytes} = Protox.Varint.decode(bytes)
<<delimited::binary-size(len), rest::binary>> = bytes
value = CucumberMessages.TestStepFinished.TestStepResult.decode!(delimited)
field = {:test_step_result, Protox.Message.merge(msg.test_step_result(), value)}
{field, rest}
{2, _, bytes} ->
{len, bytes} = Protox.Varint.decode(bytes)
<<delimited::binary-size(len), rest::binary>> = bytes
value = CucumberMessages.Timestamp.decode!(delimited)
field = {:timestamp, Protox.Message.merge(msg.timestamp(), value)}
{field, rest}
{3, _, bytes} ->
{len, bytes} = Protox.Varint.decode(bytes)
<<delimited::binary-size(len), rest::binary>> = bytes
value = delimited
field = {:test_step_id, value}
{field, rest}
{4, _, bytes} ->
{len, bytes} = Protox.Varint.decode(bytes)
<<delimited::binary-size(len), rest::binary>> = bytes
value = delimited
field = {:test_case_started_id, value}
{field, rest}
{tag, wire_type, rest} ->
{value, new_rest} = Protox.Decode.parse_unknown(tag, wire_type, rest)
field =
{msg.__struct__.unknown_fields_name,
[value | msg.__struct__.unknown_fields(msg)]}
{field, new_rest}
end
msg_updated = struct(msg, [field])
parse_key_value(rest, msg_updated)
end
)
[]
)
@spec defs() :: %{
required(non_neg_integer) => {atom, Protox.Types.kind(), Protox.Types.type()}
}
def(defs()) do
%{
1 =>
{:test_step_result, {:default, nil},
{:message, CucumberMessages.TestStepFinished.TestStepResult}},
2 => {:timestamp, {:default, nil}, {:message, CucumberMessages.Timestamp}},
3 => {:test_step_id, {:default, ""}, :string},
4 => {:test_case_started_id, {:default, ""}, :string}
}
end
@spec defs_by_name() :: %{
required(atom) => {non_neg_integer, Protox.Types.kind(), Protox.Types.type()}
}
def(defs_by_name()) do
%{
test_case_started_id: {4, {:default, ""}, :string},
test_step_id: {3, {:default, ""}, :string},
test_step_result:
{1, {:default, nil}, {:message, CucumberMessages.TestStepFinished.TestStepResult}},
timestamp: {2, {:default, nil}, {:message, CucumberMessages.Timestamp}}
}
end
@spec required_fields() :: []
def(required_fields()) do
[]
end
@spec unknown_fields(struct) :: [{non_neg_integer, Protox.Types.tag(), binary}]
def(unknown_fields(msg)) do
msg.__uf__()
end
@spec unknown_fields_name() :: :__uf__
def(unknown_fields_name()) do
:__uf__
end
@spec clear_unknown_fields(struct) :: struct
def(clear_unknown_fields(msg)) do
struct!(msg, [{unknown_fields_name(), []}])
end
@spec syntax() :: atom
def(syntax()) do
:proto3
end
[
@spec(
default(atom) :: {:ok, boolean | integer | String.t() | binary | float} | {:error, atom}
),
[
def(default(:test_step_result)) do
{:ok, nil}
end,
def(default(:timestamp)) do
{:ok, nil}
end,
def(default(:test_step_id)) do
{:ok, ""}
end,
def(default(:test_case_started_id)) do
{:ok, ""}
end
],
def(default(_)) do
{:error, :no_such_field}
end
]
)
[]
end
]