From 4d48849db89fa275ee0716da12e7a88195b59e54 Mon Sep 17 00:00:00 2001 From: Thomas Poignant Date: Thu, 28 Jul 2022 20:32:45 +0200 Subject: [PATCH 01/50] Introducing the new InternalFlag and all the associated behaviors Signed-off-by: Thomas Poignant --- exporter/common_test.go | 2 +- exporter/feature_event.go | 4 +- exporter/feature_event_test.go | 4 +- exporter/fileexporter/exporter_test.go | 4 +- .../fileexporter/testdata/all_default.json | 4 +- .../testdata/custom_file_name.json | 4 +- exporter/s3exporter/testdata/all_default.json | 2 +- exporter/webhookexporter/exporter_test.go | 6 +- .../testdata/valid_with_signature.json | 4 +- .../testdata/valid_without_signature.json | 4 +- go.mod | 3 + go.sum | 6 + internal/dataexporter/data_exporter_test.go | 10 +- internal/fflog/log.go | 4 +- internal/flag/error_code.go | 6 + internal/flag/flag.go | 20 +- internal/flag/internal_flag.go | 229 +++++ internal/flag/internal_flag_test.go | 805 ++++++++++++++++++ internal/flag/percentage_bucket.go | 8 + internal/flag/resolution_detail.go | 8 + internal/flag/rollout.go | 13 + internal/flag/rollout_experimentation.go | 13 + internal/flag/rollout_experimentation_test.go | 52 ++ internal/flag/rollout_progressive.go | 49 ++ internal/flag/rollout_scheduled.go | 11 + internal/flag/rollout_scheduled_test.go | 85 ++ internal/flag/rule.go | 271 ++++++ internal/flag/rule_test.go | 697 +++++++++++++++ internal/flag/variation_selection.go | 17 + internal/flagv1/flag_data.go | 26 +- internal/flagv1/flag_pub_test.go | 203 +++-- internal/internalerror/targeting_not_apply.go | 15 + internal/model/variation_result.go | 2 +- internal/utils/hash_test.go | 27 + internal/utils/slice.go | 11 + internal/utils/slice_test.go | 39 + internal/utils/stringAppender.go | 12 + notifier/logsnotifier/notifier.go | 4 +- notifier/slacknotifier/notifier.go | 71 +- notifier/slacknotifier/notifier_test.go | 2 + ...d_call_webhook_and_have_valid_results.json | 83 +- .../marshal_json/error_in_flag_0.json | 6 +- testutils/testconvert/convert_types.go | 5 + variation.go | 12 +- 44 files changed, 2588 insertions(+), 275 deletions(-) create mode 100644 internal/flag/internal_flag.go create mode 100644 internal/flag/internal_flag_test.go create mode 100644 internal/flag/percentage_bucket.go create mode 100644 internal/flag/rollout.go create mode 100644 internal/flag/rollout_experimentation.go create mode 100644 internal/flag/rollout_experimentation_test.go create mode 100644 internal/flag/rollout_progressive.go create mode 100644 internal/flag/rollout_scheduled.go create mode 100644 internal/flag/rollout_scheduled_test.go create mode 100644 internal/flag/rule.go create mode 100644 internal/flag/rule_test.go create mode 100644 internal/flag/variation_selection.go create mode 100644 internal/internalerror/targeting_not_apply.go create mode 100644 internal/utils/hash_test.go create mode 100644 internal/utils/slice.go create mode 100644 internal/utils/slice_test.go create mode 100644 internal/utils/stringAppender.go diff --git a/exporter/common_test.go b/exporter/common_test.go index 36c6d8f394d..7ff9cb7b65c 100644 --- a/exporter/common_test.go +++ b/exporter/common_test.go @@ -167,7 +167,7 @@ func TestFormatEventInJSON(t *testing.T) { Kind: "feature", ContextKind: "anonymousUser", UserKey: "ABCD", CreationDate: 1617970547, Key: "random-key", Variation: "Default", Value: "YO", Default: false, }}, - want: "{\"kind\":\"feature\",\"contextKind\":\"anonymousUser\",\"userKey\":\"ABCD\",\"creationDate\":1617970547,\"key\":\"random-key\",\"variation\":\"Default\",\"value\":\"YO\",\"default\":false,\"version\":0}\n", + want: "{\"kind\":\"feature\",\"contextKind\":\"anonymousUser\",\"userKey\":\"ABCD\",\"creationDate\":1617970547,\"key\":\"random-key\",\"variation\":\"Default\",\"value\":\"YO\",\"default\":false,\"version\":\"\"}\n", wantErr: assert.NoError, }, } diff --git a/exporter/feature_event.go b/exporter/feature_event.go index b830546fd05..4d75b480131 100644 --- a/exporter/feature_event.go +++ b/exporter/feature_event.go @@ -12,7 +12,7 @@ func NewFeatureEvent( value interface{}, variation string, failed bool, - version float64, + version string, ) FeatureEvent { contextKind := "user" if user.IsAnonymous() { @@ -65,5 +65,5 @@ type FeatureEvent struct { // Version contains the version of the flag. If the field is omitted for the flag in the configuration file // the default version will be 0. - Version float64 `json:"version"` + Version string `json:"version"` } diff --git a/exporter/feature_event_test.go b/exporter/feature_event_test.go index c41b1d93438..a51e54664f6 100644 --- a/exporter/feature_event_test.go +++ b/exporter/feature_event_test.go @@ -16,7 +16,7 @@ func TestNewFeatureEvent(t *testing.T) { value interface{} variation string failed bool - version float64 + version string } tests := []struct { name string @@ -31,7 +31,7 @@ func TestNewFeatureEvent(t *testing.T) { value: "YO", variation: "Default", failed: false, - version: 0, + version: "", }, want: exporter.FeatureEvent{ Kind: "feature", ContextKind: "anonymousUser", UserKey: "ABCD", CreationDate: time.Now().Unix(), Key: "random-key", diff --git a/exporter/fileexporter/exporter_test.go b/exporter/fileexporter/exporter_test.go index 5db9baa6357..b6a85bee64e 100644 --- a/exporter/fileexporter/exporter_test.go +++ b/exporter/fileexporter/exporter_test.go @@ -49,7 +49,7 @@ func TestFile_Export(t *testing.T) { }, { Kind: "feature", ContextKind: "anonymousUser", UserKey: "EFGH", CreationDate: 1617970701, Key: "random-key", - Variation: "Default", Value: "YO2", Default: false, Version: 127, + Variation: "Default", Value: "YO2", Default: false, Version: "127", }, }, }, @@ -143,7 +143,7 @@ func TestFile_Export(t *testing.T) { }, { Kind: "feature", ContextKind: "anonymousUser", UserKey: "EFGH", CreationDate: 1617970701, Key: "random-key", - Variation: "Default", Value: "YO2", Default: false, Version: 127, + Variation: "Default", Value: "YO2", Default: false, Version: "127", }, }, }, diff --git a/exporter/fileexporter/testdata/all_default.json b/exporter/fileexporter/testdata/all_default.json index 552f33d4069..99ab92ad5bd 100644 --- a/exporter/fileexporter/testdata/all_default.json +++ b/exporter/fileexporter/testdata/all_default.json @@ -1,2 +1,2 @@ -{"kind":"feature","contextKind":"anonymousUser","userKey":"ABCD","creationDate":1617970547,"key":"random-key","variation":"Default","value":"YO","default":false,"version":0} -{"kind":"feature","contextKind":"anonymousUser","userKey":"EFGH","creationDate":1617970701,"key":"random-key","variation":"Default","value":"YO2","default":false,"version":127} +{"kind":"feature","contextKind":"anonymousUser","userKey":"ABCD","creationDate":1617970547,"key":"random-key","variation":"Default","value":"YO","default":false,"version":""} +{"kind":"feature","contextKind":"anonymousUser","userKey":"EFGH","creationDate":1617970701,"key":"random-key","variation":"Default","value":"YO2","default":false,"version":"127"} diff --git a/exporter/fileexporter/testdata/custom_file_name.json b/exporter/fileexporter/testdata/custom_file_name.json index 8354aec9c40..891251dd748 100644 --- a/exporter/fileexporter/testdata/custom_file_name.json +++ b/exporter/fileexporter/testdata/custom_file_name.json @@ -1,2 +1,2 @@ -{"kind":"feature","contextKind":"anonymousUser","userKey":"ABCD","creationDate":1617970547,"key":"random-key","variation":"Default","value":"YO","default":false,"version":0} -{"kind":"feature","contextKind":"anonymousUser","userKey":"EFGH","creationDate":1617970701,"key":"random-key","variation":"Default","value":"YO2","default":false,"version":0} +{"kind":"feature","contextKind":"anonymousUser","userKey":"ABCD","creationDate":1617970547,"key":"random-key","variation":"Default","value":"YO","default":false,"version":""} +{"kind":"feature","contextKind":"anonymousUser","userKey":"EFGH","creationDate":1617970701,"key":"random-key","variation":"Default","value":"YO2","default":false,"version":""} diff --git a/exporter/s3exporter/testdata/all_default.json b/exporter/s3exporter/testdata/all_default.json index 5798af02c1c..9e702153e2e 100644 --- a/exporter/s3exporter/testdata/all_default.json +++ b/exporter/s3exporter/testdata/all_default.json @@ -1 +1 @@ -{"kind":"feature","contextKind":"anonymousUser","userKey":"ABCD","creationDate":1617970547,"key":"random-key","variation":"Default","value":"YO","default":false,"version":0} +{"kind":"feature","contextKind":"anonymousUser","userKey":"ABCD","creationDate":1617970547,"key":"random-key","variation":"Default","value":"YO","default":false,"version":""} diff --git a/exporter/webhookexporter/exporter_test.go b/exporter/webhookexporter/exporter_test.go index bad8e43f2dd..42b80117540 100644 --- a/exporter/webhookexporter/exporter_test.go +++ b/exporter/webhookexporter/exporter_test.go @@ -66,7 +66,7 @@ func TestWebhook_Export(t *testing.T) { }, { Kind: "feature", ContextKind: "anonymousUser", UserKey: "EFGH", CreationDate: 1617970701, Key: "random-key", - Variation: "Default", Value: "YO2", Default: false, Version: 127, + Variation: "Default", Value: "YO2", Default: false, Version: "127", }, }, }, @@ -93,13 +93,13 @@ func TestWebhook_Export(t *testing.T) { }, { Kind: "feature", ContextKind: "anonymousUser", UserKey: "EFGH", CreationDate: 1617970701, Key: "random-key", - Variation: "Default", Value: "YO2", Default: false, Version: 127, + Variation: "Default", Value: "YO2", Default: false, Version: "127", }, }, }, expected: expected{ bodyFilePath: "./testdata/valid_with_signature.json", - signHeader: "sha256=1ac12dcfbc2f5734a949b301c251a542384735c5552d8570e25bf5a4e7c21a32", + signHeader: "sha256=0c504fe37d423ff0a80e4dc29b93c18c2d1438a5387f36d8e6491e77fb5e70d4", }, wantErr: false, }, diff --git a/exporter/webhookexporter/testdata/valid_with_signature.json b/exporter/webhookexporter/testdata/valid_with_signature.json index cd775b48c4c..6467446841e 100644 --- a/exporter/webhookexporter/testdata/valid_with_signature.json +++ b/exporter/webhookexporter/testdata/valid_with_signature.json @@ -12,7 +12,7 @@ "variation": "Default", "value": "YO", "default": false, - "version": 0 + "version": "" }, { "kind": "feature", @@ -23,7 +23,7 @@ "variation": "Default", "value": "YO2", "default": false, - "version": 127 + "version": "127" } ] } diff --git a/exporter/webhookexporter/testdata/valid_without_signature.json b/exporter/webhookexporter/testdata/valid_without_signature.json index cd775b48c4c..6467446841e 100644 --- a/exporter/webhookexporter/testdata/valid_without_signature.json +++ b/exporter/webhookexporter/testdata/valid_without_signature.json @@ -12,7 +12,7 @@ "variation": "Default", "value": "YO", "default": false, - "version": 0 + "version": "" }, { "kind": "feature", @@ -23,7 +23,7 @@ "variation": "Default", "value": "YO2", "default": false, - "version": 127 + "version": "127" } ] } diff --git a/go.mod b/go.mod index 428ef60c675..6987bb82199 100644 --- a/go.mod +++ b/go.mod @@ -5,10 +5,12 @@ go 1.17 require ( cloud.google.com/go/storage v1.23.0 github.com/aws/aws-sdk-go v1.44.46 + github.com/gdexlab/go-render v1.0.1 github.com/golang/mock v1.6.0 github.com/google/go-cmp v0.5.8 github.com/nikunjy/rules v1.1.0 github.com/pelletier/go-toml v1.9.5 + github.com/r3labs/diff/v3 v3.0.0 github.com/stretchr/testify v1.8.0 golang.org/x/oauth2 v0.0.0-20220622183110-fd043fe589d2 google.golang.org/api v0.86.0 @@ -51,6 +53,7 @@ require ( github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822 // indirect github.com/pkg/errors v0.9.1 // indirect github.com/pmezard/go-difflib v1.0.0 // indirect + github.com/vmihailenco/msgpack v4.0.4+incompatible // indirect go.opencensus.io v0.23.0 // indirect golang.org/x/net v0.0.0-20220624214902-1bab6f366d9e // indirect golang.org/x/sys v0.0.0-20220624220833-87e55d714810 // indirect diff --git a/go.sum b/go.sum index 036515c19da..92162a7974f 100644 --- a/go.sum +++ b/go.sum @@ -127,6 +127,8 @@ github.com/form3tech-oss/jwt-go v3.2.3+incompatible/go.mod h1:pbq4aXjuKjdthFRnoD github.com/fsnotify/fsnotify v1.4.7/go.mod h1:jwhsz4b93w/PPRr/qN1Yymfu8t87LnFCMoQvtojpjFo= github.com/fsnotify/fsnotify v1.4.9 h1:hsms1Qyu0jgnwNXIxa+/V/PDsU6CfLf6CNO8H7IWoS4= github.com/fsnotify/fsnotify v1.4.9/go.mod h1:znqG4EE+3YCdAaPaxE2ZRY/06pZUdp0tY4IgpuI1SZQ= +github.com/gdexlab/go-render v1.0.1 h1:rxqB3vo5s4n1kF0ySmoNeSPRYkEsyHgln4jFIQY7v0U= +github.com/gdexlab/go-render v1.0.1/go.mod h1:wRi5nW2qfjiGj4mPukH4UV0IknS1cHD4VgFTmJX5JzM= github.com/getkin/kin-openapi v0.76.0/go.mod h1:660oXbgy5JFMKreazJaQTw7o+X00qeSyhcnluiMv+Xg= github.com/ghodss/yaml v1.0.0/go.mod h1:4dBDuWmgqj2HViK6kFavaiC9ZROes6MMH2rRYeMEF04= github.com/go-gl/glfw v0.0.0-20190409004039-e6da0acd62b1/go.mod h1:vR7hzQXu2zJy9AVAgeJqvqgH9Q5CA+iKCZ2gyEVpxRU= @@ -310,6 +312,8 @@ github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINE github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM= github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= github.com/prometheus/client_model v0.0.0-20190812154241-14fe0d1b01d4/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA= +github.com/r3labs/diff/v3 v3.0.0 h1:ZhPwNxn9gW5WLPBV9GCYaVbMdLOSmJ0DeKdCiSbOLUI= +github.com/r3labs/diff/v3 v3.0.0/go.mod h1:wCkTySAiDnZao1sZrVTDIzuzgLZ+cNPGn3LC8DlIg5g= github.com/rogpeppe/fastuuid v1.2.0/go.mod h1:jVj6XXZzXRy/MSR5jhDC/2q6DgLz+nrA6LYCDYWNEvQ= github.com/rogpeppe/go-internal v1.3.0/go.mod h1:M8bDsm7K2OlrFYOpmOWEs/qY81heoFRclV5y23lUDJ4= github.com/spaolacci/murmur3 v0.0.0-20180118202830-f09979ecbc72/go.mod h1:JwIasOWyU6f++ZhiEuf87xNszmSA2myDM2Kzu9HwQUA= @@ -327,6 +331,8 @@ github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/ github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= github.com/stretchr/testify v1.8.0 h1:pSgiaMZlXftHpm5L7V1+rVB+AZJydKsMxsQBIJw4PKk= github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU= +github.com/vmihailenco/msgpack v4.0.4+incompatible h1:dSLoQfGFAo3F6OoNhwUmLwVgaUXK79GlxNBwueZn0xI= +github.com/vmihailenco/msgpack v4.0.4+incompatible/go.mod h1:fy3FlTQTDXWkZ7Bh6AcGMlsjHatGryHQYUTf1ShIgkk= github.com/yuin/goldmark v1.1.25/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74= github.com/yuin/goldmark v1.1.27/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74= github.com/yuin/goldmark v1.1.32/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74= diff --git a/internal/dataexporter/data_exporter_test.go b/internal/dataexporter/data_exporter_test.go index dc06c904632..8b4f7b0af03 100644 --- a/internal/dataexporter/data_exporter_test.go +++ b/internal/dataexporter/data_exporter_test.go @@ -29,7 +29,7 @@ func TestDataExporterScheduler_flushWithTime(t *testing.T) { inputEvents := []exporter.FeatureEvent{ exporter.NewFeatureEvent(ffuser.NewAnonymousUser("ABCD"), "random-key", - "YO", flagv1.VariationDefault, false, 0), + "YO", flagv1.VariationDefault, false, ""), } for _, event := range inputEvents { @@ -50,7 +50,7 @@ func TestDataExporterScheduler_flushWithNumberOfEvents(t *testing.T) { var inputEvents []exporter.FeatureEvent for i := 0; i <= 100; i++ { inputEvents = append(inputEvents, exporter.NewFeatureEvent(ffuser.NewAnonymousUser("ABCD"), - "random-key", "YO", flagv1.VariationDefault, false, 0)) + "random-key", "YO", flagv1.VariationDefault, false, "")) } for _, event := range inputEvents { dc.AddEvent(event) @@ -68,7 +68,7 @@ func TestDataExporterScheduler_defaultFlush(t *testing.T) { var inputEvents []exporter.FeatureEvent for i := 0; i <= 100000; i++ { inputEvents = append(inputEvents, exporter.NewFeatureEvent(ffuser.NewAnonymousUser("ABCD"), - "random-key", "YO", flagv1.VariationDefault, false, 0)) + "random-key", "YO", flagv1.VariationDefault, false, "")) } for _, event := range inputEvents { dc.AddEvent(event) @@ -92,7 +92,7 @@ func TestDataExporterScheduler_exporterReturnError(t *testing.T) { var inputEvents []exporter.FeatureEvent for i := 0; i <= 200; i++ { inputEvents = append(inputEvents, exporter.NewFeatureEvent(ffuser.NewAnonymousUser("ABCD"), - "random-key", "YO", flagv1.VariationDefault, false, 0)) + "random-key", "YO", flagv1.VariationDefault, false, "")) } for _, event := range inputEvents { dc.AddEvent(event) @@ -113,7 +113,7 @@ func TestDataExporterScheduler_nonBulkExporter(t *testing.T) { var inputEvents []exporter.FeatureEvent for i := 0; i < 100; i++ { inputEvents = append(inputEvents, exporter.NewFeatureEvent(ffuser.NewAnonymousUser("ABCD"), - "random-key", "YO", flagv1.VariationDefault, false, 0)) + "random-key", "YO", flagv1.VariationDefault, false, "")) } for _, event := range inputEvents { dc.AddEvent(event) diff --git a/internal/fflog/log.go b/internal/fflog/log.go index ad05d94d173..a3a37d43d52 100644 --- a/internal/fflog/log.go +++ b/internal/fflog/log.go @@ -5,9 +5,11 @@ import ( "time" ) +const LogDateFormat = time.RFC3339 + func Printf(logger *log.Logger, format string, v ...interface{}) { if logger != nil { - date := time.Now().Format(time.RFC3339) + date := time.Now().Format(LogDateFormat) v = append([]interface{}{date}, v...) logger.Printf("[%v] "+format, v...) } diff --git a/internal/flag/error_code.go b/internal/flag/error_code.go index b177f39924e..d9024e297dd 100644 --- a/internal/flag/error_code.go +++ b/internal/flag/error_code.go @@ -4,9 +4,15 @@ package flag type ErrorCode = string const ( + // Proposed in the open-feature specs ErrorCodeProviderNotReady ErrorCode = "PROVIDER_NOT_READY" ErrorCodeFlagNotFound ErrorCode = "FLAG_NOT_FOUND" ErrorCodeParseError ErrorCode = "PARSE_ERROR" ErrorCodeTypeMismatch ErrorCode = "TYPE_MISMATCH" ErrorCodeGeneral ErrorCode = "GENERAL" + + // Custom error code for Go Feature Flag + + // ErrorFlagConfiguration is returned when we were not able to use the flag because of a misconfiguration + ErrorFlagConfiguration ErrorCode = "FLAG_CONFIG" ) diff --git a/internal/flag/flag.go b/internal/flag/flag.go index f6369445188..c830f5e6aef 100644 --- a/internal/flag/flag.go +++ b/internal/flag/flag.go @@ -13,24 +13,16 @@ type Flag interface { // GetVersion is the getter for the field Version // Default: 0.0 - GetVersion() float64 + GetVersion() string - // GetTrackEvents is the getter of the field TrackEvents + // IsTrackEvents is the getter of the field TrackEvents // Default: true - GetTrackEvents() bool + IsTrackEvents() bool - // GetDisable is the getter for the field Disable + // IsDisable is the getter for the field Disable // Default: false - GetDisable() bool - - // GetDefaultVariation return the name of the default variation (if something goes wrong) - GetDefaultVariation() string + IsDisable() bool // GetVariationValue return the value of variation from his name - GetVariationValue(variationName string) interface{} - - // GetRawValues is returning a raw value of the Flag used by the notifiers - // We should not have any logic based on these values, this is only to - // display the information. - GetRawValues() map[string]string + GetVariationValue(name string) interface{} } diff --git a/internal/flag/internal_flag.go b/internal/flag/internal_flag.go new file mode 100644 index 00000000000..20d9f2b48c8 --- /dev/null +++ b/internal/flag/internal_flag.go @@ -0,0 +1,229 @@ +package flag + +import ( + "fmt" + "time" + + "github.com/thomaspoignant/go-feature-flag/ffuser" + "github.com/thomaspoignant/go-feature-flag/internal/internalerror" + "github.com/thomaspoignant/go-feature-flag/internal/utils" +) + +const ( + PercentageMultiplier = float64(1000) + MaxPercentage = uint32(100 * PercentageMultiplier) +) + +// InternalFlag is the internal representation of a flag when using go-feature-flag. +// All the flags in your configuration files can have different format but will be +// converted into an InternalFlag to be used in the library. +type InternalFlag struct { + // Variations are all the variations available for this flag. The minimum is 2 variations and, we don't have any max + // limit except if the variationValue is a bool, the max is 2. + Variations *map[string]*interface{} `json:"variations,omitempty" yaml:"variations,omitempty" toml:"variations,omitempty"` // nolint:lll + + // Rules is the list of Rule for this flag. + // This an optional field. + Rules *[]Rule `json:"targeting,omitempty" yaml:"targeting,omitempty" toml:"targeting,omitempty"` + + // DefaultRule is the originalRule applied after checking that any other rules + // matched the user. + DefaultRule *Rule `json:"defaultRule,omitempty" yaml:"defaultRule,omitempty" toml:"defaultRule,omitempty"` + + // Rollout is how we roll out the flag + Rollout *Rollout `json:"rollout,omitempty" yaml:"rollout,omitempty" toml:"rollout,omitempty"` + + // TrackEvents is false if you don't want to export the data in your data exporter. + // Default value is true + TrackEvents *bool `json:"trackEvents,omitempty" yaml:"trackEvents,omitempty" toml:"trackEvents,omitempty"` + + // Disable is true if the flag is disabled. + Disable *bool `json:"disable,omitempty" yaml:"disable,omitempty" toml:"disable,omitempty"` + + // Version (optional) This field contains the version of the flag. + // The version is manually managed when you configure your flags, and it is used to display the information + // in the notifications and data collection. + Version *string `json:"version,omitempty" yaml:"version,omitempty" toml:"version,omitempty"` +} + +// Value is returning the Value associate to the flag +func (f *InternalFlag) Value( + flagName string, + user ffuser.User, + evaluationCtx EvaluationContext, +) (interface{}, ResolutionDetails) { + f.applyScheduledRolloutSteps() + + if f.IsDisable() || f.isExperimentationOver() { + return evaluationCtx.DefaultSdkValue, ResolutionDetails{Variant: VariationSDKDefault, Reason: ReasonDisabled} + } + + variationSelection, err := f.selectVariation(flagName, user) + if err != nil { + return evaluationCtx.DefaultSdkValue, + ResolutionDetails{ + Variant: VariationSDKDefault, + Reason: ReasonError, + ErrorCode: ErrorFlagConfiguration, + } + } + + return f.GetVariationValue(variationSelection.name), ResolutionDetails{ + Variant: variationSelection.name, + Reason: variationSelection.reason, + RuleIndex: variationSelection.ruleIndex, + RuleName: variationSelection.ruleName, + } +} + +// selectVariation is doing the magic to select the variation that should be used for this specific user +// to always affect the user to the same segment we are using a hash of the flag name + key +func (f *InternalFlag) selectVariation(flagName string, user ffuser.User) (*variationSelection, error) { + hashID := utils.Hash(flagName+user.GetKey()) % MaxPercentage + + // Check all targeting in order, the first to match will be the one used. + if len(f.GetRules()) != 0 { + for ruleIndex, target := range f.GetRules() { + variationName, err := target.Evaluate(user, hashID, false) + if err != nil { + // the targeting does not apply + if _, ok := err.(*internalerror.RuleNotApply); ok { + continue + } + return nil, err + } + return &variationSelection{ + name: variationName, + reason: ReasonTargetingMatch, + ruleIndex: &ruleIndex, + ruleName: f.GetRules()[ruleIndex].Name, + }, err + } + } + + if f.DefaultRule == nil { + return nil, fmt.Errorf("no default targeting for the flag") + } + + variationName, err := f.GetDefaultRule().Evaluate(user, hashID, true) + if err != nil { + return nil, err + } + + return &variationSelection{name: variationName, reason: ReasonDefault}, nil +} + +// nolint: gocognit +// applyScheduledRolloutSteps is checking if the flag has a scheduled rollout configured. +// If yes we merge the changes to the current flag. +func (f *InternalFlag) applyScheduledRolloutSteps() { + evaluationDate := time.Now() + if f.Rollout != nil && f.Rollout.Scheduled != nil { + for _, steps := range *f.Rollout.Scheduled { + if steps.Date != nil && steps.Date.Before(evaluationDate) { + f.Rules = MergeSetOfRules(f.GetRules(), steps.GetRules()) + if steps.Disable != nil { + f.Disable = steps.Disable + } + + if steps.TrackEvents != nil { + f.TrackEvents = steps.TrackEvents + } + + if steps.DefaultRule != nil { + f.DefaultRule.MergeRules(*steps.DefaultRule) + } + + if steps.Variations != nil { + for key, value := range steps.GetVariations() { + f.GetVariations()[key] = value + } + } + + if steps.Version != nil { + f.Version = steps.Version + } + + if steps.Rollout != nil && steps.Rollout.Experimentation != nil { + if f.Rollout.Experimentation == nil { + f.Rollout.Experimentation = &ExperimentationRollout{} + } + if steps.Rollout.Experimentation.Start != nil { + f.Rollout.Experimentation.End = steps.Rollout.Experimentation.End + } + if steps.Rollout.Experimentation.End != nil { + f.Rollout.Experimentation.End = steps.Rollout.Experimentation.End + } + } + } + } + } +} + +// isExperimentationOver checks if we are in an experimentation or not +func (f *InternalFlag) isExperimentationOver() bool { + now := time.Now() + return f.Rollout != nil && + f.Rollout.Experimentation != nil && + ((f.Rollout.Experimentation.Start != nil && now.Before(*f.Rollout.Experimentation.Start)) || + (f.Rollout.Experimentation.End != nil && now.After(*f.Rollout.Experimentation.End))) +} + +// GetVariations is the getter of the field Variations +func (f *InternalFlag) GetVariations() map[string]*interface{} { + if f.Variations == nil { + return map[string]*interface{}{} + } + return *f.Variations +} + +func (f *InternalFlag) GetRules() []Rule { + if f.Rules == nil { + return []Rule{} + } + return *f.Rules +} + +// GetDefaultRule is the getter of the field DefaultRule +func (f *InternalFlag) GetDefaultRule() *Rule { + return f.DefaultRule +} + +// IsTrackEvents is the getter of the field TrackEvents +func (f *InternalFlag) IsTrackEvents() bool { + if f.TrackEvents == nil { + return true + } + return *f.TrackEvents +} + +// IsDisable is the getter for the field Disable +func (f *InternalFlag) IsDisable() bool { + if f.Disable == nil { + return false + } + return *f.Disable +} + +// GetVersion is the getter for the field Version +func (f *InternalFlag) GetVersion() string { + if f.Version == nil { + return "" + } + return *f.Version +} + +// GetRollout is the getter for the field Rollout +func (f *InternalFlag) GetRollout() *Rollout { + return f.Rollout +} + +// GetVariationValue return the value of variation from his name +func (f *InternalFlag) GetVariationValue(name string) interface{} { + for k, v := range f.GetVariations() { + if k == name { + return v + } + } + return nil +} diff --git a/internal/flag/internal_flag_test.go b/internal/flag/internal_flag_test.go new file mode 100644 index 00000000000..67854961540 --- /dev/null +++ b/internal/flag/internal_flag_test.go @@ -0,0 +1,805 @@ +package flag_test + +import ( + "fmt" + "testing" + "time" + + "github.com/google/go-cmp/cmp" + "github.com/stretchr/testify/assert" + "github.com/thomaspoignant/go-feature-flag/ffuser" + "github.com/thomaspoignant/go-feature-flag/internal/flag" + "github.com/thomaspoignant/go-feature-flag/testutils/testconvert" +) + +func TestInternalFlag_Value(t *testing.T) { + type args struct { + flagName string + user ffuser.User + evaluationCtx flag.EvaluationContext + } + tests := []struct { + name string + flag flag.InternalFlag + args args + want interface{} + want1 flag.ResolutionDetails + }{ + { + name: "Should use default value if no targeting", + flag: flag.InternalFlag{ + Variations: &map[string]*interface{}{ + "variation_A": testconvert.Interface(true), + "variation_B": testconvert.Interface(false), + }, + DefaultRule: &flag.Rule{ + VariationResult: testconvert.String("variation_A"), + }, + }, + args: args{ + flagName: "my-flag", + user: ffuser.NewUser("user-key"), + evaluationCtx: flag.EvaluationContext{ + DefaultSdkValue: false, + }, + }, + want: testconvert.Interface(true), + want1: flag.ResolutionDetails{ + Variant: "variation_A", + Reason: flag.ReasonDefault, + }, + }, + { + name: "Should return sdk default value when flag is disabled", + flag: flag.InternalFlag{ + Disable: testconvert.Bool(true), + }, + args: args{ + flagName: "my-flag", + user: ffuser.NewUser("user-key"), + evaluationCtx: flag.EvaluationContext{ + DefaultSdkValue: testconvert.Interface("default-sdk"), + }, + }, + want: testconvert.Interface("default-sdk"), + want1: flag.ResolutionDetails{ + Variant: "SdkDefault", + Reason: flag.ReasonDisabled, + }, + }, + { + name: "Should return sdk default value when experimentation rollout not started", + flag: flag.InternalFlag{ + Rollout: &flag.Rollout{ + Experimentation: &flag.ExperimentationRollout{ + Start: testconvert.Time(time.Now().Add(1 * time.Second)), + End: testconvert.Time(time.Now().Add(5 * time.Second)), + }, + }, + }, + args: args{ + flagName: "my-flag", + user: ffuser.NewUser("user-key"), + evaluationCtx: flag.EvaluationContext{ + DefaultSdkValue: testconvert.Interface("default-sdk"), + }, + }, + want: testconvert.Interface("default-sdk"), + want1: flag.ResolutionDetails{ + Variant: "SdkDefault", + Reason: flag.ReasonDisabled, + }, + }, + { + name: "Should return sdk default value when experimentation rollout ended", + flag: flag.InternalFlag{ + Rollout: &flag.Rollout{ + Experimentation: &flag.ExperimentationRollout{ + Start: testconvert.Time(time.Now().Add(-15 * time.Second)), + End: testconvert.Time(time.Now().Add(-5 * time.Second)), + }, + }, + }, + args: args{ + flagName: "my-flag", + user: ffuser.NewUser("user-key"), + evaluationCtx: flag.EvaluationContext{ + DefaultSdkValue: testconvert.Interface("default-sdk"), + }, + }, + want: testconvert.Interface("default-sdk"), + want1: flag.ResolutionDetails{ + Variant: "SdkDefault", + Reason: flag.ReasonDisabled, + }, + }, + { + name: "Should return the variation specified in the rule if rule match", + flag: flag.InternalFlag{ + Variations: &map[string]*interface{}{ + "variation_A": testconvert.Interface(true), + "variation_B": testconvert.Interface(false), + }, + Rules: &[]flag.Rule{ + { + Name: testconvert.String("rule1"), + Query: testconvert.String("key eq \"user-key\""), + VariationResult: testconvert.String("variation_B"), + }, + }, + DefaultRule: &flag.Rule{ + VariationResult: testconvert.String("variation_A"), + }, + }, + args: args{ + flagName: "my-flag", + user: ffuser.NewUser("user-key"), + evaluationCtx: flag.EvaluationContext{ + DefaultSdkValue: false, + }, + }, + want: testconvert.Interface(false), + want1: flag.ResolutionDetails{ + Variant: "variation_B", + Reason: flag.ReasonTargetingMatch, + RuleIndex: testconvert.Int(0), + RuleName: testconvert.String("rule1"), + }, + }, + { + name: "Should match the 2nd rule", + flag: flag.InternalFlag{ + Variations: &map[string]*interface{}{ + "variation_A": testconvert.Interface("value_A"), + "variation_B": testconvert.Interface("value_B"), + "variation_C": testconvert.Interface("value_C"), + }, + Rules: &[]flag.Rule{ + { + Name: testconvert.String("rule1"), + Query: testconvert.String("key eq \"not-user-key\""), + VariationResult: testconvert.String("variation_C"), + }, + { + Name: testconvert.String("rule2"), + Query: testconvert.String("key eq \"user-key\""), + VariationResult: testconvert.String("variation_C"), + }, + }, + DefaultRule: &flag.Rule{ + VariationResult: testconvert.String("variation_A"), + }, + }, + args: args{ + flagName: "my-flag", + user: ffuser.NewUser("user-key"), + evaluationCtx: flag.EvaluationContext{ + DefaultSdkValue: testconvert.Interface("value_default"), + }, + }, + want: testconvert.Interface("value_C"), + want1: flag.ResolutionDetails{ + Variant: "variation_C", + Reason: flag.ReasonTargetingMatch, + RuleIndex: testconvert.Int(1), + RuleName: testconvert.String("rule2"), + }, + }, + { + name: "Should match a rule with no name", + flag: flag.InternalFlag{ + Variations: &map[string]*interface{}{ + "variation_A": testconvert.Interface("value_A"), + "variation_B": testconvert.Interface("value_B"), + "variation_C": testconvert.Interface("value_C"), + }, + Rules: &[]flag.Rule{ + { + Query: testconvert.String("key eq \"not-user-key\""), + VariationResult: testconvert.String("variation_C"), + }, + { + Query: testconvert.String("key eq \"user-key\""), + VariationResult: testconvert.String("variation_C"), + }, + }, + DefaultRule: &flag.Rule{ + VariationResult: testconvert.String("variation_A"), + }, + }, + args: args{ + flagName: "my-flag", + user: ffuser.NewUser("user-key"), + evaluationCtx: flag.EvaluationContext{ + DefaultSdkValue: testconvert.Interface("value_default"), + }, + }, + want: testconvert.Interface("value_C"), + want1: flag.ResolutionDetails{ + Variant: "variation_C", + Reason: flag.ReasonTargetingMatch, + RuleIndex: testconvert.Int(1), + }, + }, + { + name: "Should match only the first rule that apply (even if more than one can apply)å", + flag: flag.InternalFlag{ + Variations: &map[string]*interface{}{ + "variation_A": testconvert.Interface("value_A"), + "variation_B": testconvert.Interface("value_B"), + "variation_C": testconvert.Interface("value_C"), + "variation_D": testconvert.Interface("value_D"), + }, + Rules: &[]flag.Rule{ + { + Query: testconvert.String("key eq \"not-user-key\""), + VariationResult: testconvert.String("variation_C"), + }, + { + Query: testconvert.String("company eq \"go-feature-flag\""), + VariationResult: testconvert.String("variation_D"), + }, + { + Query: testconvert.String("key eq \"user-key\""), + VariationResult: testconvert.String("variation_C"), + }, + }, + DefaultRule: &flag.Rule{ + VariationResult: testconvert.String("variation_A"), + }, + }, + args: args{ + flagName: "my-flag", + user: ffuser.NewUserBuilder("user-key").AddCustom("company", "go-feature-flag").Build(), + evaluationCtx: flag.EvaluationContext{ + DefaultSdkValue: testconvert.Interface("value_default"), + }, + }, + want: testconvert.Interface("value_D"), + want1: flag.ResolutionDetails{ + Variant: "variation_D", + Reason: flag.ReasonTargetingMatch, + RuleIndex: testconvert.Int(1), + }, + }, + { + name: "Should return an error if rule is invalid", + flag: flag.InternalFlag{ + Variations: &map[string]*interface{}{ + "variation_A": testconvert.Interface("value_A"), + "variation_B": testconvert.Interface("value_B"), + "variation_C": testconvert.Interface("value_C"), + "variation_D": testconvert.Interface("value_D"), + }, + Rules: &[]flag.Rule{ + { + Query: testconvert.String("key eq \"user-key\""), + Percentages: &map[string]float64{ + "variation_A": 10, + "variation_B": 100, + }, + }, + }, + DefaultRule: &flag.Rule{ + VariationResult: testconvert.String("variation_A"), + }, + }, + args: args{ + flagName: "my-flag", + user: ffuser.NewUserBuilder("user-key").Build(), + evaluationCtx: flag.EvaluationContext{ + DefaultSdkValue: testconvert.Interface("value_default"), + }, + }, + want: testconvert.Interface("value_default"), + want1: flag.ResolutionDetails{ + Variant: flag.VariationSDKDefault, + Reason: flag.ReasonError, + ErrorCode: flag.ErrorFlagConfiguration, + }, + }, + { + name: "Should return an error if no targeting match and we have no default rule", + flag: flag.InternalFlag{ + Variations: &map[string]*interface{}{ + "variation_A": testconvert.Interface("value_A"), + "variation_B": testconvert.Interface("value_B"), + "variation_C": testconvert.Interface("value_C"), + "variation_D": testconvert.Interface("value_D"), + }, + Rules: &[]flag.Rule{ + { + Query: testconvert.String("key eq \"not-user-key\""), + Percentages: &map[string]float64{ + "variation_A": 10, + "variation_B": 100, + }, + }, + }, + }, + args: args{ + flagName: "my-flag", + user: ffuser.NewUserBuilder("user-key").Build(), + evaluationCtx: flag.EvaluationContext{ + DefaultSdkValue: testconvert.Interface("value_default"), + }, + }, + want: testconvert.Interface("value_default"), + want1: flag.ResolutionDetails{ + Variant: flag.VariationSDKDefault, + Reason: flag.ReasonError, + ErrorCode: flag.ErrorFlagConfiguration, + }, + }, + { + name: "Should return an error if default rule is invalid", + flag: flag.InternalFlag{ + Variations: &map[string]*interface{}{ + "variation_A": testconvert.Interface("value_A"), + "variation_B": testconvert.Interface("value_B"), + "variation_C": testconvert.Interface("value_C"), + "variation_D": testconvert.Interface("value_D"), + }, + DefaultRule: &flag.Rule{ + Percentages: &map[string]float64{ + "variation_A": 10, + "variation_B": 100, + }, + }, + }, + args: args{ + flagName: "my-flag", + user: ffuser.NewUserBuilder("user-key").Build(), + evaluationCtx: flag.EvaluationContext{ + DefaultSdkValue: testconvert.Interface("value_default"), + }, + }, + want: testconvert.Interface("value_default"), + want1: flag.ResolutionDetails{ + Variant: flag.VariationSDKDefault, + Reason: flag.ReasonError, + ErrorCode: flag.ErrorFlagConfiguration, + }, + }, + { + name: "Should not have any change if all scheduled steps are in the future", + flag: flag.InternalFlag{ + Variations: &map[string]*interface{}{ + "variation_A": testconvert.Interface("value_A"), + "variation_B": testconvert.Interface("value_B"), + }, + DefaultRule: &flag.Rule{ + VariationResult: testconvert.String("variation_A"), + }, + Rollout: &flag.Rollout{ + Scheduled: &[]flag.ScheduledStep{ + { + InternalFlag: flag.InternalFlag{ + DefaultRule: &flag.Rule{ + VariationResult: testconvert.String("variation_B"), + }, + }, + Date: testconvert.Time(time.Now().Add(1 * time.Second)), + }, + { + InternalFlag: flag.InternalFlag{ + Variations: &map[string]*interface{}{ + "variation_A": testconvert.Interface("value_QWERTY"), + }, + }, + Date: testconvert.Time(time.Now().Add(2 * time.Second)), + }, + }, + }, + }, + args: args{ + flagName: "my-flag", + user: ffuser.NewUserBuilder("user-key").Build(), + evaluationCtx: flag.EvaluationContext{ + DefaultSdkValue: testconvert.Interface("value_default"), + }, + }, + want: testconvert.Interface("value_A"), + want1: flag.ResolutionDetails{ + Variant: "variation_A", + Reason: flag.ReasonDefault, + }, + }, + { + name: "Should only apply 1 scheduled step", + flag: flag.InternalFlag{ + Variations: &map[string]*interface{}{ + "variation_A": testconvert.Interface("value_A"), + "variation_B": testconvert.Interface("value_B"), + }, + DefaultRule: &flag.Rule{ + VariationResult: testconvert.String("variation_A"), + }, + Rollout: &flag.Rollout{ + Scheduled: &[]flag.ScheduledStep{ + { + InternalFlag: flag.InternalFlag{ + DefaultRule: &flag.Rule{ + VariationResult: testconvert.String("variation_B"), + }, + }, + Date: testconvert.Time(time.Now().Add(-1 * time.Second)), + }, + { + InternalFlag: flag.InternalFlag{ + Variations: &map[string]*interface{}{ + "variation_B": testconvert.Interface("value_QWERTY"), + }, + }, + Date: testconvert.Time(time.Now().Add(2 * time.Second)), + }, + }, + }, + }, + args: args{ + flagName: "my-flag", + user: ffuser.NewUserBuilder("user-key").Build(), + evaluationCtx: flag.EvaluationContext{ + DefaultSdkValue: testconvert.Interface("value_default"), + }, + }, + want: testconvert.Interface("value_B"), + want1: flag.ResolutionDetails{ + Variant: "variation_B", + Reason: flag.ReasonDefault, + }, + }, + { + name: "Should apply all scheduled steps in the past", + flag: flag.InternalFlag{ + Variations: &map[string]*interface{}{ + "variation_A": testconvert.Interface("value_A"), + "variation_B": testconvert.Interface("value_B"), + }, + DefaultRule: &flag.Rule{ + VariationResult: testconvert.String("variation_A"), + }, + Rollout: &flag.Rollout{ + Scheduled: &[]flag.ScheduledStep{ + { + InternalFlag: flag.InternalFlag{ + DefaultRule: &flag.Rule{ + VariationResult: testconvert.String("variation_B"), + }, + }, + Date: testconvert.Time(time.Now().Add(-2 * time.Second)), + }, + { + InternalFlag: flag.InternalFlag{ + Variations: &map[string]*interface{}{ + "variation_B": testconvert.Interface("value_QWERTY"), + }, + }, + Date: testconvert.Time(time.Now().Add(-1 * time.Second)), + }, + }, + }, + }, + args: args{ + flagName: "my-flag", + user: ffuser.NewUserBuilder("user-key").Build(), + evaluationCtx: flag.EvaluationContext{ + DefaultSdkValue: testconvert.Interface("value_default"), + }, + }, + want: testconvert.Interface("value_QWERTY"), + want1: flag.ResolutionDetails{ + Variant: "variation_B", + Reason: flag.ReasonDefault, + }, + }, + { + name: "Should ignore scheduled steps with no dates", + flag: flag.InternalFlag{ + Variations: &map[string]*interface{}{ + "variation_A": testconvert.Interface("value_A"), + "variation_B": testconvert.Interface("value_B"), + }, + DefaultRule: &flag.Rule{ + VariationResult: testconvert.String("variation_A"), + }, + Rollout: &flag.Rollout{ + Scheduled: &[]flag.ScheduledStep{ + { + InternalFlag: flag.InternalFlag{ + Variations: &map[string]*interface{}{ + "variation_A": testconvert.Interface("value_QWERTY"), + }, + }, + }, + }, + }, + }, + args: args{ + flagName: "my-flag", + user: ffuser.NewUserBuilder("user-key").Build(), + evaluationCtx: flag.EvaluationContext{ + DefaultSdkValue: testconvert.Interface("value_default"), + }, + }, + want: testconvert.Interface("value_A"), + want1: flag.ResolutionDetails{ + Variant: "variation_A", + Reason: flag.ReasonDefault, + }, + }, + { + name: "Should update a rule that exists with a scheduled step", + flag: flag.InternalFlag{ + Variations: &map[string]*interface{}{ + "variation_A": testconvert.Interface("value_A"), + "variation_B": testconvert.Interface("value_B"), + }, + Rules: &[]flag.Rule{ + { + Name: testconvert.String("rule1"), + Query: testconvert.String("key eq \"user-key\""), + VariationResult: testconvert.String("variation_B"), + }, + }, + DefaultRule: &flag.Rule{ + VariationResult: testconvert.String("variation_A"), + }, + Rollout: &flag.Rollout{ + Scheduled: &[]flag.ScheduledStep{ + { + Date: testconvert.Time(time.Now().Add(-1 * time.Second)), + InternalFlag: flag.InternalFlag{ + Variations: &map[string]*interface{}{ + "variation_C": testconvert.Interface("value_C"), + }, + Rules: &[]flag.Rule{ + { + Name: testconvert.String("rule1"), + VariationResult: testconvert.String("variation_C"), + }, + }, + }, + }, + }, + }, + }, + args: args{ + flagName: "my-flag", + user: ffuser.NewUserBuilder("user-key").Build(), + evaluationCtx: flag.EvaluationContext{ + DefaultSdkValue: testconvert.Interface("value_default"), + }, + }, + want: testconvert.Interface("value_C"), + want1: flag.ResolutionDetails{ + Variant: "variation_C", + Reason: flag.ReasonTargetingMatch, + RuleIndex: testconvert.Int(0), + RuleName: testconvert.String("rule1"), + }, + }, + { + name: "Should update default rule with a scheduled step", + flag: flag.InternalFlag{ + Variations: &map[string]*interface{}{ + "variation_A": testconvert.Interface("value_A"), + "variation_B": testconvert.Interface("value_B"), + "variation_C": testconvert.Interface("value_C"), + }, + DefaultRule: &flag.Rule{ + Percentages: &map[string]float64{ + "variation_A": 10, + "variation_B": 90, + }, + }, + Rollout: &flag.Rollout{ + Scheduled: &[]flag.ScheduledStep{ + { + Date: testconvert.Time(time.Now().Add(-2 * time.Second)), + InternalFlag: flag.InternalFlag{ + DefaultRule: &flag.Rule{ + Percentages: &map[string]float64{ + "variation_B": 20, + "variation_C": 70, + }, + }, + }, + }, + }, + }, + }, + args: args{ + flagName: "my-flag", + user: ffuser.NewUserBuilder("user-key-123").Build(), + evaluationCtx: flag.EvaluationContext{ + DefaultSdkValue: testconvert.Interface("value_default"), + }, + }, + want: testconvert.Interface("value_C"), + want1: flag.ResolutionDetails{ + Variant: "variation_C", + Reason: flag.ReasonDefault, + }, + }, + { + name: "Should add a new rule with a scheduled step", + flag: flag.InternalFlag{ + Variations: &map[string]*interface{}{ + "variation_A": testconvert.Interface("value_A"), + "variation_B": testconvert.Interface("value_B"), + }, + Rules: &[]flag.Rule{ + { + Name: testconvert.String("rule1"), + Query: testconvert.String("key eq \"user-key\""), + VariationResult: testconvert.String("variation_B"), + }, + }, + DefaultRule: &flag.Rule{ + VariationResult: testconvert.String("variation_A"), + }, + Rollout: &flag.Rollout{ + Scheduled: &[]flag.ScheduledStep{ + { + Date: testconvert.Time(time.Now().Add(-1 * time.Second)), + InternalFlag: flag.InternalFlag{ + Variations: &map[string]*interface{}{ + "variation_C": testconvert.Interface("value_C"), + }, + Rules: &[]flag.Rule{ + { + Name: testconvert.String("rule2"), + Query: testconvert.String("key eq \"user-key-123\""), + VariationResult: testconvert.String("variation_C"), + }, + }, + }, + }, + }, + }, + }, + args: args{ + flagName: "my-flag", + user: ffuser.NewUserBuilder("user-key-123").Build(), + evaluationCtx: flag.EvaluationContext{ + DefaultSdkValue: testconvert.Interface("value_default"), + }, + }, + want: testconvert.Interface("value_C"), + want1: flag.ResolutionDetails{ + Variant: "variation_C", + Reason: flag.ReasonTargetingMatch, + RuleIndex: testconvert.Int(1), + RuleName: testconvert.String("rule2"), + }, + }, + { + name: "Should apply all the changes if all scheduled steps are in the past", + flag: flag.InternalFlag{ + Variations: &map[string]*interface{}{ + "variation_A": testconvert.Interface("value_A"), + "variation_B": testconvert.Interface("value_B"), + }, + DefaultRule: &flag.Rule{ + VariationResult: testconvert.String("variation_A"), + }, + Rollout: &flag.Rollout{ + Scheduled: &[]flag.ScheduledStep{ + { + InternalFlag: flag.InternalFlag{ + DefaultRule: &flag.Rule{ + VariationResult: testconvert.String("variation_B"), + }, + }, + Date: testconvert.Time(time.Now().Add(-2 * time.Second)), + }, + { + InternalFlag: flag.InternalFlag{ + Variations: &map[string]*interface{}{ + "variation_B": testconvert.Interface("value_QWERTY"), + }, + }, + Date: testconvert.Time(time.Now().Add(-1 * time.Second)), + }, + }, + }, + }, + args: args{ + flagName: "my-flag", + user: ffuser.NewUserBuilder("user-key").Build(), + evaluationCtx: flag.EvaluationContext{ + DefaultSdkValue: testconvert.Interface("value_default"), + }, + }, + want: testconvert.Interface("value_QWERTY"), + want1: flag.ResolutionDetails{ + Variant: "variation_B", + Reason: flag.ReasonDefault, + }, + }, + { + name: "Should disable the flag with a scheduled step", + flag: flag.InternalFlag{ + Variations: &map[string]*interface{}{ + "variation_A": testconvert.Interface("value_A"), + "variation_B": testconvert.Interface("value_B"), + }, + DefaultRule: &flag.Rule{ + VariationResult: testconvert.String("variation_A"), + }, + Rollout: &flag.Rollout{ + Scheduled: &[]flag.ScheduledStep{ + { + InternalFlag: flag.InternalFlag{ + Disable: testconvert.Bool(true), + TrackEvents: testconvert.Bool(false), + Version: testconvert.String("1.0.0"), + }, + Date: testconvert.Time(time.Now().Add(-2 * time.Second)), + }, + }, + }, + }, + args: args{ + flagName: "my-flag", + user: ffuser.NewUserBuilder("user-key").Build(), + evaluationCtx: flag.EvaluationContext{ + DefaultSdkValue: testconvert.Interface("value_default"), + }, + }, + want: testconvert.Interface("value_default"), + want1: flag.ResolutionDetails{ + Variant: flag.VariationSDKDefault, + Reason: flag.ReasonDisabled, + }, + }, + { + name: "Should create an experimentation for a dedicated time", + flag: flag.InternalFlag{ + Variations: &map[string]*interface{}{ + "variation_A": testconvert.Interface("value_A"), + "variation_B": testconvert.Interface("value_B"), + }, + DefaultRule: &flag.Rule{ + VariationResult: testconvert.String("variation_A"), + }, + Rollout: &flag.Rollout{ + Scheduled: &[]flag.ScheduledStep{ + { + InternalFlag: flag.InternalFlag{ + Rollout: &flag.Rollout{ + Experimentation: &flag.ExperimentationRollout{ + Start: testconvert.Time(time.Now().Add(-2 * time.Second)), + End: testconvert.Time(time.Now().Add(2 * time.Second)), + }, + }, + }, + Date: testconvert.Time(time.Now().Add(-1 * time.Second)), + }, + }, + }, + }, + args: args{ + flagName: "my-flag", + user: ffuser.NewUserBuilder("user-key").Build(), + evaluationCtx: flag.EvaluationContext{ + DefaultSdkValue: testconvert.Interface("value_default"), + }, + }, + want: testconvert.Interface("value_A"), + want1: flag.ResolutionDetails{ + Variant: "variation_A", + Reason: flag.ReasonDefault, + }, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + got, got1 := tt.flag.Value(tt.args.flagName, tt.args.user, tt.args.evaluationCtx) + fmt.Println() + assert.Equalf(t, tt.want, got, "not expected value: %s", cmp.Diff(tt.want, got)) + assert.Equalf(t, tt.want1, got1, "not expected value: %s", cmp.Diff(tt.want1, got1)) + }) + } +} diff --git a/internal/flag/percentage_bucket.go b/internal/flag/percentage_bucket.go new file mode 100644 index 00000000000..964603cbd4a --- /dev/null +++ b/internal/flag/percentage_bucket.go @@ -0,0 +1,8 @@ +package flag + +// percentageBucket is an internal representation of the limits of the +// bucket for a variation. +type percentageBucket struct { + start float64 + end float64 +} diff --git a/internal/flag/resolution_detail.go b/internal/flag/resolution_detail.go index d06a0aa36d1..278a1df6b0f 100644 --- a/internal/flag/resolution_detail.go +++ b/internal/flag/resolution_detail.go @@ -1,5 +1,7 @@ package flag +// ResolutionDetails is the object used to manipulate the data internally, it allows to retrieve +// the details of your evaluation. type ResolutionDetails struct { // Variant indicates the name of the variant used when evaluating the flag Variant string @@ -9,4 +11,10 @@ type ResolutionDetails struct { // ErrorCode indicates the error code for this evaluation ErrorCode ErrorCode + + // RuleIndex indicates which rules applied + RuleIndex *int + + // RuleName (optional) is the name of the associated rule if we have one + RuleName *string } diff --git a/internal/flag/rollout.go b/internal/flag/rollout.go new file mode 100644 index 00000000000..e6ea1e9d63f --- /dev/null +++ b/internal/flag/rollout.go @@ -0,0 +1,13 @@ +package flag + +type Rollout struct { + // Experimentation is your struct to configure an experimentation, it will allow you to configure a start date and + // an end date for your flag. + // When the experimentation is not running, the flag will serve the default value. + Experimentation *ExperimentationRollout `json:"experimentation,omitempty" yaml:"experimentation,omitempty" toml:"experimentation,omitempty"` // nolint: lll + + // Scheduled is your struct to configure an update on some fields of your flag over time. + // You can add several steps that updates the flag, this is typically used if you want to gradually add more user + // in your flag. + Scheduled *[]ScheduledStep `json:"steps,omitempty" yaml:"steps,omitempty" toml:"steps,omitempty"` +} diff --git a/internal/flag/rollout_experimentation.go b/internal/flag/rollout_experimentation.go new file mode 100644 index 00000000000..d495f94e808 --- /dev/null +++ b/internal/flag/rollout_experimentation.go @@ -0,0 +1,13 @@ +package flag + +import ( + "time" +) + +type ExperimentationRollout struct { + // Start is the starting time of the experimentation + Start *time.Time `json:"start,omitempty" yaml:"start,omitempty" toml:"start,omitempty"` + + // End is the ending time of the experimentation + End *time.Time `json:"end,omitempty" yaml:"end,omitempty" toml:"end,omitempty"` +} diff --git a/internal/flag/rollout_experimentation_test.go b/internal/flag/rollout_experimentation_test.go new file mode 100644 index 00000000000..0c48db7cf3e --- /dev/null +++ b/internal/flag/rollout_experimentation_test.go @@ -0,0 +1,52 @@ +package flag_test + +import ( + "testing" +) + +func TestExperimentation_String(t *testing.T) { + // type fields struct { + // StartDate *time.Time + // EndDate *time.Time + // Start *time.Time + // End *time.Time + //} + // tests := []struct { + // name string + // fields fields + // want string + // }{ + // { + // name: "both dates", + // fields: fields{ + // Start: testconvert.Time(time.Unix(1095379400, 0)), + // End: testconvert.Time(time.Unix(1095379500, 0)), + // }, + // want: "start:[2004-09-17T00:03:20Z] end:[2004-09-17T00:05:00Z]", + // }, + // { + // name: "only start date", + // fields: fields{ + // Start: testconvert.Time(time.Unix(1095379400, 0)), + // }, + // want: "start:[2004-09-17T00:03:20Z]", + // }, + // { + // name: "only end date", + // fields: fields{ + // End: testconvert.Time(time.Unix(1095379500, 0)), + // }, + // want: "end:[2004-09-17T00:05:00Z]", + // }, + //} + // for _, tt := range tests { + // t.Run(tt.name, func(t *testing.T) { + // e := flag.ExperimentationRollout{ + // End: tt.fields.End, + // Start: tt.fields.Start, + // } + // got := e.String() + // assert.Equal(t, tt.want, got) + // }) + //} +} diff --git a/internal/flag/rollout_progressive.go b/internal/flag/rollout_progressive.go new file mode 100644 index 00000000000..8b6d1290ebc --- /dev/null +++ b/internal/flag/rollout_progressive.go @@ -0,0 +1,49 @@ +package flag + +import ( + "time" +) + +// ProgressiveRollout represents how to progressively roll out a originalRule. +type ProgressiveRollout struct { + // Initial contains a description of the initial state of the rollout. + Initial *ProgressiveRolloutStep `json:"initial,omitempty" yaml:"initial,omitempty" toml:"initial,omitempty"` + + // End contains what describes the end status of the rollout. + End *ProgressiveRolloutStep `json:"end,omitempty" yaml:"end,omitempty" toml:"end,omitempty"` +} + +// ProgressiveRolloutStep define a progressive rollout step (initial and end) +type ProgressiveRolloutStep struct { + Variation *string + Percentage *float64 + Date *time.Time +} + +func (p *ProgressiveRolloutStep) getVariation() string { + if p.Variation == nil { + return "" + } + return *p.Variation +} + +func (p *ProgressiveRolloutStep) getPercentage() float64 { + if p.Percentage == nil { + return 0 + } + return *p.Percentage +} + +// mergeStep is a function that take a ProgressiveRolloutStep and update the current instance +// with all the fields that are here to be overridden. +func (p *ProgressiveRolloutStep) mergeStep(updatedStep *ProgressiveRolloutStep) { + if updatedStep.Variation != nil { + p.Variation = updatedStep.Variation + } + if updatedStep.Date != nil { + p.Date = updatedStep.Date + } + if updatedStep.Percentage != nil { + p.Percentage = updatedStep.Percentage + } +} diff --git a/internal/flag/rollout_scheduled.go b/internal/flag/rollout_scheduled.go new file mode 100644 index 00000000000..a6f9a525347 --- /dev/null +++ b/internal/flag/rollout_scheduled.go @@ -0,0 +1,11 @@ +package flag + +import ( + "time" +) + +// ScheduledStep is one change of the flag. +type ScheduledStep struct { + InternalFlag `yaml:",inline"` + Date *time.Time `json:"date,omitempty" yaml:"date,omitempty" toml:"date,omitempty"` +} diff --git a/internal/flag/rollout_scheduled_test.go b/internal/flag/rollout_scheduled_test.go new file mode 100644 index 00000000000..978b03293cb --- /dev/null +++ b/internal/flag/rollout_scheduled_test.go @@ -0,0 +1,85 @@ +package flag_test + +// func TestScheduledRollout_String(t *testing.T) { +// type fields struct { +// Steps []flag.ScheduledStep +// } +// tests := []struct { +// name string +// fields fields +// want string +// }{ +// { +// name: "Simple 2 steps", +// want: "[2021-02-01T10:10:10Z: Version:[1.10]],[2021-02-02T10:10:10Z: Variations:[A=yo,B=y1]]", +// fields: fields{Steps: []flag.ScheduledStep{ +// { +// InternalFlag: flag.InternalFlag{ +// Version: testconvert.String(fmt.Sprintf("%.2f", 1.1)), +// }, +// Date: testconvert.Time(time.Date(2021, time.February, 1, 10, 10, 10, 10, time.UTC)), +// }, +// { +// InternalFlag: flag.InternalFlag{ +// Variations: &map[string]*interface{}{ +// "A": testconvert.Interface("yo"), +// "B": testconvert.Interface("y1"), +// }, +// }, +// Date: testconvert.Time(time.Date(2021, time.February, 2, 10, 10, 10, 10, time.UTC)), +// }, +// }}, +// }, +// { +// name: "Complex steps", +// want: "[2021-02-01T10:10:10Z: Version:[1.10]],[2021-02-02T10:10:10Z: Variations:[A=yo,B=y1], " + +// "DefaultRule:[query:[key eq \"toto\"], percentages:" + +// "[A=10.00,B=90.00], progressiveRollout:[Initial:[Variation:[A], Percentage:[10], Date:[2021-02-01T10:10:10Z]]," + +// " End:[Variation:[B], Percentage:[90], Date:[2021-02-04T10:10:10Z]]]]]", +// fields: fields{Steps: []flag.ScheduledStep{ +// { +// InternalFlag: flag.InternalFlag{ +// Version: testconvert.String(fmt.Sprintf("%.2f", 1.1)), +// }, +// Date: testconvert.Time(time.Date(2021, time.February, 1, 10, 10, 10, 10, time.UTC)), +// }, +// { +// InternalFlag: flag.InternalFlag{ +// Variations: &map[string]*interface{}{ +// "A": testconvert.Interface("yo"), +// "B": testconvert.Interface("y1"), +// }, +// DefaultRule: &flag.Rule{ +// Query: testconvert.String("key eq \"toto\""), +// Percentages: &map[string]float64{ +// "A": 10, +// "B": 90, +// }, +// ProgressiveRollout: &flag.ProgressiveRollout{ +// Initial: &flag.ProgressiveRolloutStep{ +// Variation: testconvert.String("A"), +// Percentage: 10, +// Date: testconvert.Time(time.Date(2021, time.February, 1, 10, 10, 10, 10, time.UTC)), +// }, +// End: &flag.ProgressiveRolloutStep{ +// Variation: testconvert.String("B"), +// Percentage: 90, +// Date: testconvert.Time(time.Date(2021, time.February, 4, 10, 10, 10, 10, time.UTC)), +// }, +// }, +// }, +// }, +// Date: testconvert.Time(time.Date(2021, time.February, 2, 10, 10, 10, 10, time.UTC)), +// }, +// }}, +// }, +// } +// for _, tt := range tests { +// t.Run(tt.name, func(t *testing.T) { +// s := flag.ScheduledRollout{ +// Steps: tt.fields.Steps, +// } +// assert.Equalf(t, tt.want, s.String(), "String()") +// }) +// } +//} diff --git a/internal/flag/rule.go b/internal/flag/rule.go new file mode 100644 index 00000000000..a44b5d7049c --- /dev/null +++ b/internal/flag/rule.go @@ -0,0 +1,271 @@ +package flag + +import ( + "errors" + "fmt" + "sort" + "time" + + "github.com/nikunjy/rules/parser" + "github.com/thomaspoignant/go-feature-flag/ffuser" + "github.com/thomaspoignant/go-feature-flag/internal/internalerror" + "github.com/thomaspoignant/go-feature-flag/internal/utils" +) + +// Rule represents a originalRule applied by the flag. +type Rule struct { + // Name is the name of the originalRule, this field is mandatory if you want + // to update the originalRule during scheduled rollout + Name *string `json:"name,omitempty" yaml:"name,omitempty" toml:"name,omitempty"` + + // Query represents an antlr query in the nikunjy/rules format + Query *string `json:"query,omitempty" yaml:"query,omitempty" toml:"query,omitempty"` + + // VariationResult represents the variation name to use if the originalRule apply for the user. + // In case we have a percentage field in the config VariationResult is ignored + VariationResult *string `json:"variation,omitempty" yaml:"variation,omitempty" toml:"variation,omitempty"` // nolint: lll + + // Percentages represents the percentage we should give to each variation. + // example: variationA = 10%, variationB = 80%, variationC = 10% + Percentages *map[string]float64 `json:"percentage,omitempty" yaml:"percentage,omitempty" toml:"percentage,omitempty"` // nolint: lll + + // ProgressiveRollout is your struct to configure a progressive rollout deployment of your flag. + // It will allow you to ramp up the percentage of your flag over time. + // You can decide at which percentage you starts with and at what percentage you ends with in your release ramp. + // Before the start date we will serve the initial percentage and, after we will serve the end percentage. + ProgressiveRollout *ProgressiveRollout `json:"progressiveRollout,omitempty" yaml:"progressiveRollout,omitempty" toml:"progressiveRollout,omitempty"` // nolint: lll +} + +// Evaluate is checking if the originalRule apply to for the user. +// If yes it returns the variation you should use for this originalRule. +func (r *Rule) Evaluate(user ffuser.User, hashID uint32, isDefault bool, +) (string, error) { + // Check if the originalRule apply for this user + ruleApply := isDefault || r.GetQuery() == "" || parser.Evaluate(r.GetQuery(), utils.UserToMap(user)) + if !ruleApply { + return "", &internalerror.RuleNotApply{User: user} + } + + if r.ProgressiveRollout != nil { + variation, err := r.getVariationFromProgressiveRollout(hashID) + if err != nil { + return variation, err + } + return variation, nil + } + + if r.Percentages != nil { + variationName, err := r.getVariationFromPercentage(hashID) + if err != nil { + return "", err + } + return variationName, nil + } + + if r.VariationResult != nil { + return r.GetVariationResult(), nil + } + return "", fmt.Errorf("error in the configuration, no variation available for this originalRule") +} + +func (r *Rule) getVariationFromProgressiveRollout(hash uint32) (string, error) { + isRolloutValid := r.ProgressiveRollout != nil && + r.ProgressiveRollout.Initial != nil && + r.ProgressiveRollout.Initial.Date != nil && + r.ProgressiveRollout.Initial.Variation != nil && + r.ProgressiveRollout.End != nil && + r.ProgressiveRollout.End.Date != nil && + r.ProgressiveRollout.End.Variation != nil && + r.ProgressiveRollout.End.Date.After(*r.ProgressiveRollout.Initial.Date) + + if isRolloutValid { + now := time.Now() + if now.Before(*r.ProgressiveRollout.Initial.Date) { + return *r.ProgressiveRollout.Initial.Variation, nil + } + + if now.After(*r.ProgressiveRollout.End.Date) { + return *r.ProgressiveRollout.End.Variation, nil + } + + // We are between initial and end + initialPercentage := r.ProgressiveRollout.Initial.getPercentage() * PercentageMultiplier + if r.ProgressiveRollout.End.getPercentage() == 0 || r.ProgressiveRollout.End.getPercentage() > 100 { + max := float64(100) + r.ProgressiveRollout.End.Percentage = &max + } + endPercentage := r.ProgressiveRollout.End.getPercentage() * PercentageMultiplier + + nbSec := r.ProgressiveRollout.End.Date.Unix() - r.ProgressiveRollout.Initial.Date.Unix() + percentage := endPercentage - initialPercentage + percentPerSec := percentage / float64(nbSec) + + c := now.Unix() - r.ProgressiveRollout.Initial.Date.Unix() + currentPercentage := float64(c)*percentPerSec + initialPercentage + + if hash < uint32(currentPercentage) { + return r.ProgressiveRollout.End.getVariation(), nil + } + return r.ProgressiveRollout.Initial.getVariation(), nil + } + return "", fmt.Errorf("error in the progressive rollout, missing params") +} + +func (r *Rule) getVariationFromPercentage(hash uint32) (string, error) { + buckets, err := r.getPercentageBuckets() + if err != nil { + return "", err + } + + for key, bucket := range buckets { + if uint32(bucket.start) <= hash && uint32(bucket.end) > hash { + return key, nil + } + } + return "", fmt.Errorf("impossible to find the variation") +} + +// getPercentageBuckets compute a map containing the buckets of each variation for this originalRule. +func (r *Rule) getPercentageBuckets() (map[string]percentageBucket, error) { + percentageBuckets := make(map[string]percentageBucket, len(r.GetPercentages())) + percentage := r.GetPercentages() + + // we need to sort the map to affect the bucket to be sure we are constantly affecting the users to the same bucket. + // Map are not ordered in GO, so we have to order the variationNames to be able to compute the same numbers for the + // buckets everytime we are in this function. + variationNames := make([]string, 0) + for k := range percentage { + variationNames = append(variationNames, k) + } + // HACK: we are reversing the sort to support the legacy format of the flags (before 1.0.0) and to be sure to always + // have "True" before "False" + sort.Sort(sort.Reverse(sort.StringSlice(variationNames))) + + for index, varName := range variationNames { + startBucket := float64(0) + if index != 0 { + startBucket = percentageBuckets[variationNames[index-1]].end + } + endBucket := startBucket + (percentage[varName] * PercentageMultiplier) + + percentageBuckets[varName] = percentageBucket{ + start: startBucket, + end: endBucket, + } + } + + lastElementInBuckets := percentageBuckets[variationNames[len(variationNames)-1]].end + if lastElementInBuckets != float64(MaxPercentage) { + return nil, errors.New("invalid originalRule because percentage are not representing 100%") + } + + return percentageBuckets, nil +} + +// MergeRules is merging 2 rules. +// It is used when we have to update a originalRule in a scheduled rollout. +func (r *Rule) MergeRules(updatedRule Rule) { + if updatedRule.Query != nil { + r.Query = updatedRule.Query + } + + if updatedRule.VariationResult != nil { + r.VariationResult = updatedRule.VariationResult + } + + if updatedRule.ProgressiveRollout != nil { + c := r.GetProgressiveRollout() + if updatedRule.ProgressiveRollout.Initial != nil { + c.Initial.mergeStep(updatedRule.ProgressiveRollout.Initial) + } + + if updatedRule.ProgressiveRollout.End != nil { + c.End.mergeStep(updatedRule.ProgressiveRollout.End) + } + r.ProgressiveRollout = &c + } + + if updatedRule.Percentages != nil { + updatedPercentages := updatedRule.GetPercentages() + mergedPercentages := r.GetPercentages() + for key, percentage := range updatedPercentages { + // When you set a negative percentage we are not taking it in consideration. + if percentage < 0 { + delete(mergedPercentages, key) + continue + } + mergedPercentages[key] = percentage + } + r.Percentages = &mergedPercentages + } +} + +func (r *Rule) GetQuery() string { + if r.Query == nil { + return "" + } + return *r.Query +} + +func (r *Rule) GetVariationResult() string { + if r.VariationResult == nil { + return "" + } + return *r.VariationResult +} + +func (r *Rule) GetName() string { + if r.Name == nil { + return "" + } + return *r.Name +} + +func (r *Rule) GetPercentages() map[string]float64 { + if r.Percentages == nil { + return map[string]float64{} + } + return *r.Percentages +} + +func (r *Rule) GetProgressiveRollout() ProgressiveRollout { + if r.ProgressiveRollout == nil { + return ProgressiveRollout{ + Initial: &ProgressiveRolloutStep{}, + End: &ProgressiveRolloutStep{}, + } + } + return *r.ProgressiveRollout +} + +// MergeSetOfRules is taking a collection of rules and merge it with the updates +// from a schedule steps. +// If you want to edit a rule this rule should have a name already to be able to +// target the updates to the right place. +func MergeSetOfRules(initialRules []Rule, updates []Rule) *[]Rule { + collection := initialRules + modified := make(map[string]Rule, 0) + for _, update := range updates { + ruleName := update.Name + if ruleName != nil { + modified[update.GetName()] = update + } + } + + mergedUpdates := make([]string, 0) + for index, rule := range collection { + if _, ok := modified[rule.GetName()]; ok { + rule.MergeRules(modified[rule.GetName()]) + collection[index] = rule + mergedUpdates = append(mergedUpdates, rule.GetName()) + } + } + + for _, update := range updates { + if !utils.Contains(mergedUpdates, update.GetName()) { + collection = append(collection, update) + } + } + + return &collection +} diff --git a/internal/flag/rule_test.go b/internal/flag/rule_test.go new file mode 100644 index 00000000000..fbfcc348de8 --- /dev/null +++ b/internal/flag/rule_test.go @@ -0,0 +1,697 @@ +package flag_test + +import ( + "fmt" + "testing" + "time" + + "github.com/stretchr/testify/assert" + "github.com/thomaspoignant/go-feature-flag/ffuser" + "github.com/thomaspoignant/go-feature-flag/internal/flag" + "github.com/thomaspoignant/go-feature-flag/internal/utils" + "github.com/thomaspoignant/go-feature-flag/testutils/testconvert" +) + +func TestRule_Evaluate(t *testing.T) { + type args struct { + user ffuser.User + hashID uint32 + isDefault bool + } + tests := []struct { + name string + args args + rule flag.Rule + want string + wantErr assert.ErrorAssertionFunc + }{ + { + name: "No query, default variation result", + rule: flag.Rule{ + Name: testconvert.String("rule1"), + VariationResult: testconvert.String("variation_A"), + }, + args: args{}, + want: "variation_A", + wantErr: assert.NoError, + }, + { + name: "Ignore query if default variation result", + rule: flag.Rule{ + Name: testconvert.String("rule1"), + VariationResult: testconvert.String("variation_A"), + Query: testconvert.String("key eq \"def\""), + }, + args: args{ + isDefault: true, + user: ffuser.NewUser("abc"), + }, + want: "variation_A", + wantErr: assert.NoError, + }, + { + name: "User does not match the query", + rule: flag.Rule{ + Name: testconvert.String("rule1"), + VariationResult: testconvert.String("variation_A"), + Query: testconvert.String("key eq \"def\""), + }, + args: args{ + isDefault: false, + user: ffuser.NewUser("abc"), + }, + wantErr: assert.Error, + }, + { + name: "User match the query", + rule: flag.Rule{ + Name: testconvert.String("rule1"), + VariationResult: testconvert.String("variation_A"), + Query: testconvert.String("key eq \"abc\""), + }, + args: args{ + isDefault: false, + user: ffuser.NewUser("abc"), + }, + want: "variation_A", + wantErr: assert.NoError, + }, + { + name: "No match and no default variation", + rule: flag.Rule{ + Name: testconvert.String("rule1"), + }, + args: args{}, + wantErr: assert.Error, + }, + { + name: "Percentage ignore variation result", + rule: flag.Rule{ + Name: testconvert.String("rule1"), + VariationResult: testconvert.String("variation_A"), + Percentages: &map[string]float64{ + "variation_B": 0, + "variation_C": 100, + }, + }, + args: args{ + user: ffuser.NewUser("userkey"), + hashID: utils.Hash("flagname+userkey") % flag.MaxPercentage, + }, + wantErr: assert.NoError, + want: "variation_C", + }, + { + name: "All percentage does not fit all traffic", + rule: flag.Rule{ + Name: testconvert.String("rule1"), + Percentages: &map[string]float64{ + "variation_B": 0, + "variation_C": 99, + }, + }, + args: args{}, + wantErr: assert.Error, + }, + { + name: "All percentage are more than 100%", + rule: flag.Rule{ + Name: testconvert.String("rule1"), + Percentages: &map[string]float64{ + "variation_B": 10, + "variation_C": 100, + }, + }, + args: args{}, + wantErr: assert.Error, + }, + { + name: "Percentage in 1st bucket", + rule: flag.Rule{ + Name: testconvert.String("rule1"), + Percentages: &map[string]float64{ + "variation_C": 9, + "variation_B": 91, + }, + }, + args: args{ + user: ffuser.NewUser("userkey"), + hashID: utils.Hash("flagname+userkey") % flag.MaxPercentage, + }, + wantErr: assert.NoError, + want: "variation_C", + }, + { + name: "Percentage in 2nd bucket", + rule: flag.Rule{ + Name: testconvert.String("rule1"), + Percentages: &map[string]float64{ + "variation_D": 70, + "variation_C": 10, + "variation_B": 20, + }, + }, + args: args{ + user: ffuser.NewUser("randomUserID"), + hashID: utils.Hash("flagname+randomUserID") % flag.MaxPercentage, + }, + wantErr: assert.NoError, + want: "variation_C", + }, + { + name: "Percentage in 3rd bucket", + rule: flag.Rule{ + Name: testconvert.String("rule1"), + Percentages: &map[string]float64{ + "variation_D": 70, + "variation_C": 10, + "variation_B": 20, + }, + }, + args: args{ + user: ffuser.NewUser("userkey"), + hashID: utils.Hash("flagname+96ac59e6-7492-436b-b15a-ba1d797d2423") % flag.MaxPercentage, + }, + wantErr: assert.NoError, + want: "variation_B", + }, + { + name: "Hash more than max (not supposed to happen)", + rule: flag.Rule{ + Name: testconvert.String("rule1"), + Percentages: &map[string]float64{ + "variation_B": 100, + }, + }, + args: args{ + user: ffuser.NewUser("userkey"), + hashID: flag.MaxPercentage + 1, + }, + wantErr: assert.Error, + }, + { + name: "Percentage + user match query", + rule: flag.Rule{ + Name: testconvert.String("rule1"), + Percentages: &map[string]float64{ + "variation_D": 70, + "variation_C": 10, + "variation_B": 20, + }, + Query: testconvert.String("key eq \"userkey\""), + }, + args: args{ + user: ffuser.NewUser("userkey"), + hashID: utils.Hash("flagname+96ac59e6-7492-436b-b15a-ba1d797d2423") % flag.MaxPercentage, + }, + wantErr: assert.NoError, + want: "variation_B", + }, + { + name: "Progressive rollout ignore percentage", + rule: flag.Rule{ + Name: testconvert.String("rule1"), + Percentages: &map[string]float64{ + "variation_A": 100, + }, + ProgressiveRollout: &flag.ProgressiveRollout{ + Initial: &flag.ProgressiveRolloutStep{ + Variation: testconvert.String("variation_B"), + Percentage: testconvert.Float64(0), + Date: testconvert.Time(time.Now().Add(0 * time.Second)), + }, + End: &flag.ProgressiveRolloutStep{ + Variation: testconvert.String("variation_C"), + Percentage: testconvert.Float64(100), + Date: testconvert.Time(time.Now().Add(3 * time.Second)), + }, + }, + }, + args: args{ + user: ffuser.NewUser("userkey"), + hashID: utils.Hash("flagname+userKey") % flag.MaxPercentage, + }, + wantErr: assert.NoError, + want: "variation_B", + }, + { + name: "Progressive rollout before ramp", + rule: flag.Rule{ + Name: testconvert.String("rule1"), + ProgressiveRollout: &flag.ProgressiveRollout{ + Initial: &flag.ProgressiveRolloutStep{ + Variation: testconvert.String("variation_B"), + Percentage: testconvert.Float64(0), + Date: testconvert.Time(time.Now().Add(1 * time.Second)), + }, + End: &flag.ProgressiveRolloutStep{ + Variation: testconvert.String("variation_C"), + Percentage: testconvert.Float64(100), + Date: testconvert.Time(time.Now().Add(3 * time.Second)), + }, + }, + }, + args: args{ + user: ffuser.NewUser("userkey"), + hashID: utils.Hash("flagname+userKey") % flag.MaxPercentage, + }, + wantErr: assert.NoError, + want: "variation_B", + }, + { + name: "Progressive rollout after ramp", + rule: flag.Rule{ + Name: testconvert.String("rule1"), + ProgressiveRollout: &flag.ProgressiveRollout{ + Initial: &flag.ProgressiveRolloutStep{ + Variation: testconvert.String("variation_B"), + Percentage: testconvert.Float64(0), + Date: testconvert.Time(time.Now().Add(-6 * time.Second)), + }, + End: &flag.ProgressiveRolloutStep{ + Variation: testconvert.String("variation_C"), + Percentage: testconvert.Float64(100), + Date: testconvert.Time(time.Now().Add(-3 * time.Second)), + }, + }, + }, + args: args{ + user: ffuser.NewUser("userkey"), + hashID: utils.Hash("flagname+userKey") % flag.MaxPercentage, + }, + wantErr: assert.NoError, + want: "variation_C", + }, + { + name: "Progressive rollout in the ramp serve initial variation", + rule: flag.Rule{ + Name: testconvert.String("rule1"), + ProgressiveRollout: &flag.ProgressiveRollout{ + Initial: &flag.ProgressiveRolloutStep{ + Variation: testconvert.String("variation_B"), + Percentage: testconvert.Float64(0), + Date: testconvert.Time(time.Now().Add(-1 * time.Second)), + }, + End: &flag.ProgressiveRolloutStep{ + Variation: testconvert.String("variation_C"), + Percentage: testconvert.Float64(100), + Date: testconvert.Time(time.Now().Add(3 * time.Second)), + }, + }, + }, + args: args{ + user: ffuser.NewUser("userkey"), + hashID: utils.Hash("flagname+userKey") % flag.MaxPercentage, + }, + wantErr: assert.NoError, + want: "variation_B", + }, + { + name: "Progressive rollout in the ramp serve end variation", + rule: flag.Rule{ + Name: testconvert.String("rule1"), + ProgressiveRollout: &flag.ProgressiveRollout{ + Initial: &flag.ProgressiveRolloutStep{ + Variation: testconvert.String("variation_B"), + Percentage: testconvert.Float64(0), + Date: testconvert.Time(time.Now().Add(-3 * time.Second)), + }, + End: &flag.ProgressiveRolloutStep{ + Variation: testconvert.String("variation_C"), + Percentage: testconvert.Float64(100), + Date: testconvert.Time(time.Now().Add(1 * time.Second)), + }, + }, + }, + args: args{ + user: ffuser.NewUser("userkey"), + hashID: utils.Hash("flagname+userKey") % flag.MaxPercentage, + }, + wantErr: assert.NoError, + want: "variation_C", + }, + { + name: "Progressive rollout in the ramp serve end variation no percentage specified", + rule: flag.Rule{ + Name: testconvert.String("rule1"), + ProgressiveRollout: &flag.ProgressiveRollout{ + Initial: &flag.ProgressiveRolloutStep{ + Variation: testconvert.String("variation_B"), + Date: testconvert.Time(time.Now().Add(-3 * time.Second)), + }, + End: &flag.ProgressiveRolloutStep{ + Variation: testconvert.String("variation_C"), + Date: testconvert.Time(time.Now().Add(1 * time.Second)), + }, + }, + }, + args: args{ + user: ffuser.NewUser("userkey"), + hashID: utils.Hash("flagname+userKey") % flag.MaxPercentage, + }, + wantErr: assert.NoError, + want: "variation_C", + }, + { + name: "Progressive rollout initial before end", + rule: flag.Rule{ + Name: testconvert.String("rule1"), + ProgressiveRollout: &flag.ProgressiveRollout{ + Initial: &flag.ProgressiveRolloutStep{ + Variation: testconvert.String("variation_B"), + Percentage: testconvert.Float64(0), + Date: testconvert.Time(time.Now().Add(3 * time.Second)), + }, + End: &flag.ProgressiveRolloutStep{ + Variation: testconvert.String("variation_C"), + Percentage: testconvert.Float64(100), + Date: testconvert.Time(time.Now().Add(1 * time.Second)), + }, + }, + }, + args: args{}, + wantErr: assert.Error, + }, + { + name: "Progressive rollout no initial step", + rule: flag.Rule{ + Name: testconvert.String("rule1"), + ProgressiveRollout: &flag.ProgressiveRollout{ + End: &flag.ProgressiveRolloutStep{ + Variation: testconvert.String("variation_C"), + Percentage: testconvert.Float64(100), + Date: testconvert.Time(time.Now().Add(1 * time.Second)), + }, + }, + }, + args: args{}, + wantErr: assert.Error, + }, + { + name: "Progressive rollout no end step", + rule: flag.Rule{ + Name: testconvert.String("rule1"), + ProgressiveRollout: &flag.ProgressiveRollout{ + Initial: &flag.ProgressiveRolloutStep{ + Variation: testconvert.String("variation_B"), + Percentage: testconvert.Float64(0), + Date: testconvert.Time(time.Now().Add(3 * time.Second)), + }, + }, + }, + args: args{}, + wantErr: assert.Error, + }, + { + name: "Progressive rollout initial step with no variation", + rule: flag.Rule{ + Name: testconvert.String("rule1"), + ProgressiveRollout: &flag.ProgressiveRollout{ + Initial: &flag.ProgressiveRolloutStep{ + Percentage: testconvert.Float64(0), + Date: testconvert.Time(time.Now().Add(3 * time.Second)), + }, + End: &flag.ProgressiveRolloutStep{ + Variation: testconvert.String("variation_C"), + Percentage: testconvert.Float64(100), + Date: testconvert.Time(time.Now().Add(1 * time.Second)), + }, + }, + }, + args: args{}, + wantErr: assert.Error, + }, + { + name: "Progressive rollout end step with no variation", + rule: flag.Rule{ + Name: testconvert.String("rule1"), + ProgressiveRollout: &flag.ProgressiveRollout{ + Initial: &flag.ProgressiveRolloutStep{ + Variation: testconvert.String("variation_B"), + Percentage: testconvert.Float64(0), + Date: testconvert.Time(time.Now().Add(3 * time.Second)), + }, + End: &flag.ProgressiveRolloutStep{ + Percentage: testconvert.Float64(100), + Date: testconvert.Time(time.Now().Add(1 * time.Second)), + }, + }, + }, + args: args{}, + wantErr: assert.Error, + }, + { + name: "Progressive rollout no initial date", + rule: flag.Rule{ + Name: testconvert.String("rule1"), + ProgressiveRollout: &flag.ProgressiveRollout{ + Initial: &flag.ProgressiveRolloutStep{ + Variation: testconvert.String("variation_B"), + Percentage: testconvert.Float64(0), + }, + End: &flag.ProgressiveRolloutStep{ + Variation: testconvert.String("variation_C"), + Percentage: testconvert.Float64(100), + Date: testconvert.Time(time.Now().Add(1 * time.Second)), + }, + }, + }, + args: args{}, + wantErr: assert.Error, + }, + { + name: "Progressive rollout no end date", + rule: flag.Rule{ + Name: testconvert.String("rule1"), + ProgressiveRollout: &flag.ProgressiveRollout{ + Initial: &flag.ProgressiveRolloutStep{ + Variation: testconvert.String("variation_B"), + Percentage: testconvert.Float64(0), + Date: testconvert.Time(time.Now().Add(1 * time.Second)), + }, + End: &flag.ProgressiveRolloutStep{ + Variation: testconvert.String("variation_C"), + Percentage: testconvert.Float64(100), + }, + }, + }, + args: args{}, + wantErr: assert.Error, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + got, err := tt.rule.Evaluate(tt.args.user, tt.args.hashID, tt.args.isDefault) + if !tt.wantErr(t, err, fmt.Sprintf("Evaluate(%v, %v, %v)", tt.args.user, tt.args.hashID, tt.args.isDefault)) { + return + } + assert.Equalf(t, tt.want, got, "Evaluate(%v, %v, %v)", tt.args.user, tt.args.hashID, tt.args.isDefault) + }) + } +} + +func TestRule_MergeRules(t *testing.T) { + tests := []struct { + name string + originalRule flag.Rule + updatedRule flag.Rule + want flag.Rule + }{ + { + name: "merge simple rule", + originalRule: flag.Rule{ + Name: testconvert.String("rule1"), + VariationResult: testconvert.String("variation_A"), + }, + updatedRule: flag.Rule{ + VariationResult: testconvert.String("variation_B"), + }, + want: flag.Rule{ + Name: testconvert.String("rule1"), + VariationResult: testconvert.String("variation_B"), + }, + }, + { + name: "merge percentage", + originalRule: flag.Rule{ + Name: testconvert.String("rule1"), + Percentages: &map[string]float64{ + "variation_A": 10, + "variation_B": 10, + "variation_C": 10, + "variation_D": 10, + "variation_E": 60, + }, + }, + updatedRule: flag.Rule{ + Percentages: &map[string]float64{ + "variation_D": -1, + "variation_E": 50, + "variation_F": 20, + }, + }, + want: flag.Rule{ + Name: testconvert.String("rule1"), + Percentages: &map[string]float64{ + "variation_A": 10, + "variation_B": 10, + "variation_C": 10, + "variation_E": 50, + "variation_F": 20, + }, + }, + }, + { + name: "merge rule with query", + originalRule: flag.Rule{ + Name: testconvert.String("rule1"), + VariationResult: testconvert.String("variation_A"), + Query: testconvert.String("key eq \"abc\""), + }, + updatedRule: flag.Rule{ + Query: testconvert.String("key eq \"cde\""), + }, + want: flag.Rule{ + Name: testconvert.String("rule1"), + VariationResult: testconvert.String("variation_A"), + Query: testconvert.String("key eq \"cde\""), + }, + }, + { + name: "merge rule remove query", + originalRule: flag.Rule{ + Name: testconvert.String("rule1"), + VariationResult: testconvert.String("variation_A"), + Query: testconvert.String("key eq \"abc\""), + }, + updatedRule: flag.Rule{ + Query: testconvert.String(""), + }, + want: flag.Rule{ + Name: testconvert.String("rule1"), + VariationResult: testconvert.String("variation_A"), + Query: testconvert.String(""), + }, + }, + { + name: "merge rule with progressive rollout no rollout before", + originalRule: flag.Rule{ + Name: testconvert.String("rule1"), + VariationResult: testconvert.String("variation_A"), + }, + updatedRule: flag.Rule{ + ProgressiveRollout: &flag.ProgressiveRollout{ + Initial: &flag.ProgressiveRolloutStep{ + Variation: testconvert.String("variation_B"), + Date: testconvert.Time(time.Date(2021, time.February, 1, 10, 10, 10, 10, time.UTC)), + }, + End: &flag.ProgressiveRolloutStep{ + Variation: testconvert.String("variation_C"), + Date: testconvert.Time(time.Date(2021, time.February, 3, 10, 10, 10, 10, time.UTC)), + }, + }, + }, + want: flag.Rule{ + Name: testconvert.String("rule1"), + VariationResult: testconvert.String("variation_A"), + ProgressiveRollout: &flag.ProgressiveRollout{ + Initial: &flag.ProgressiveRolloutStep{ + Variation: testconvert.String("variation_B"), + Date: testconvert.Time(time.Date(2021, time.February, 1, 10, 10, 10, 10, time.UTC)), + }, + End: &flag.ProgressiveRolloutStep{ + Variation: testconvert.String("variation_C"), + Date: testconvert.Time(time.Date(2021, time.February, 3, 10, 10, 10, 10, time.UTC)), + }, + }, + }, + }, + { + name: "merge rule with progressive rollout update initial step", + originalRule: flag.Rule{ + Name: testconvert.String("rule1"), + VariationResult: testconvert.String("variation_A"), + ProgressiveRollout: &flag.ProgressiveRollout{ + Initial: &flag.ProgressiveRolloutStep{ + Variation: testconvert.String("variation_B"), + Date: testconvert.Time(time.Date(2021, time.February, 1, 10, 10, 10, 10, time.UTC)), + }, + End: &flag.ProgressiveRolloutStep{ + Variation: testconvert.String("variation_C"), + Date: testconvert.Time(time.Date(2021, time.February, 3, 10, 10, 10, 10, time.UTC)), + }, + }, + }, + updatedRule: flag.Rule{ + ProgressiveRollout: &flag.ProgressiveRollout{ + Initial: &flag.ProgressiveRolloutStep{ + Variation: testconvert.String("variation_D"), + Percentage: testconvert.Float64(40), + Date: testconvert.Time(time.Date(2021, time.February, 1, 10, 10, 10, 10, time.UTC)), + }, + }, + }, + want: flag.Rule{ + Name: testconvert.String("rule1"), + VariationResult: testconvert.String("variation_A"), + ProgressiveRollout: &flag.ProgressiveRollout{ + Initial: &flag.ProgressiveRolloutStep{ + Variation: testconvert.String("variation_D"), + Percentage: testconvert.Float64(40), + Date: testconvert.Time(time.Date(2021, time.February, 1, 10, 10, 10, 10, time.UTC)), + }, + End: &flag.ProgressiveRolloutStep{ + Variation: testconvert.String("variation_C"), + Date: testconvert.Time(time.Date(2021, time.February, 3, 10, 10, 10, 10, time.UTC)), + }, + }, + }, + }, + { + name: "merge rule with progressive rollout update end step", + originalRule: flag.Rule{ + Name: testconvert.String("rule1"), + VariationResult: testconvert.String("variation_A"), + ProgressiveRollout: &flag.ProgressiveRollout{ + Initial: &flag.ProgressiveRolloutStep{ + Variation: testconvert.String("variation_B"), + Date: testconvert.Time(time.Date(2021, time.February, 1, 10, 10, 10, 10, time.UTC)), + }, + End: &flag.ProgressiveRolloutStep{ + Variation: testconvert.String("variation_C"), + Date: testconvert.Time(time.Date(2021, time.February, 3, 10, 10, 10, 10, time.UTC)), + }, + }, + }, + updatedRule: flag.Rule{ + ProgressiveRollout: &flag.ProgressiveRollout{ + End: &flag.ProgressiveRolloutStep{ + Date: testconvert.Time(time.Date(2021, time.February, 12, 10, 10, 10, 10, time.UTC)), + Percentage: testconvert.Float64(100), + }, + }, + }, + want: flag.Rule{ + Name: testconvert.String("rule1"), + VariationResult: testconvert.String("variation_A"), + ProgressiveRollout: &flag.ProgressiveRollout{ + Initial: &flag.ProgressiveRolloutStep{ + Variation: testconvert.String("variation_B"), + Date: testconvert.Time(time.Date(2021, time.February, 1, 10, 10, 10, 10, time.UTC)), + }, + End: &flag.ProgressiveRolloutStep{ + Variation: testconvert.String("variation_C"), + Date: testconvert.Time(time.Date(2021, time.February, 12, 10, 10, 10, 10, time.UTC)), + Percentage: testconvert.Float64(100), + }, + }, + }, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + tt.originalRule.MergeRules(tt.updatedRule) + assert.Equal(t, tt.want, tt.originalRule) + }) + } +} diff --git a/internal/flag/variation_selection.go b/internal/flag/variation_selection.go new file mode 100644 index 00000000000..4cc6e345701 --- /dev/null +++ b/internal/flag/variation_selection.go @@ -0,0 +1,17 @@ +package flag + +// variationSelection is an internal struct used when selecting the variation +// for a flag. +type variationSelection struct { + // name of the selected variation + name string + + // reason of the selection + reason ResolutionReason + + // ruleIndex the index of the original rule which applied + ruleIndex *int + + // ruleName (optional) is the name of the associated rule if we have one + ruleName *string +} diff --git a/internal/flagv1/flag_data.go b/internal/flagv1/flag_data.go index 83f43ec9543..a02821a6bc5 100644 --- a/internal/flagv1/flag_data.go +++ b/internal/flagv1/flag_data.go @@ -73,7 +73,7 @@ func (f *FlagData) Value( } // Flag disable we cannot apply it. - if f.GetDisable() { + if f.IsDisable() { return evaluationCtx.DefaultSdkValue, flag.ResolutionDetails{ Variant: flag.VariationSDKDefault, Reason: flag.ReasonDisabled, @@ -160,14 +160,14 @@ func (f FlagData) String() string { toString = append(toString, fmt.Sprintf("true=\"%v\"", f.getTrue())) toString = append(toString, fmt.Sprintf("false=\"%v\"", f.getFalse())) toString = append(toString, fmt.Sprintf("default=\"%v\"", f.getDefault())) - toString = append(toString, fmt.Sprintf("disable=\"%v\"", f.GetDisable())) + toString = append(toString, fmt.Sprintf("disable=\"%v\"", f.IsDisable())) if f.TrackEvents != nil { - toString = append(toString, fmt.Sprintf("trackEvents=\"%v\"", f.GetTrackEvents())) + toString = append(toString, fmt.Sprintf("trackEvents=\"%v\"", f.IsTrackEvents())) } if f.Version != nil { - toString = append(toString, fmt.Sprintf("version=%s", strconv.FormatFloat(f.GetVersion(), 'f', -1, 64))) + toString = append(toString, fmt.Sprintf("version=%s", f.GetVersion())) } return strings.Join(toString, ", ") @@ -312,16 +312,16 @@ func (f *FlagData) getDefault() interface{} { return *f.Default } -// GetTrackEvents is the getter of the field TrackEvents -func (f *FlagData) GetTrackEvents() bool { +// IsTrackEvents is the getter of the field TrackEvents +func (f *FlagData) IsTrackEvents() bool { if f.TrackEvents == nil { return true } return *f.TrackEvents } -// GetDisable is the getter for the field Disable -func (f *FlagData) GetDisable() bool { +// IsDisable is the getter for the field Disable +func (f *FlagData) IsDisable() bool { if f.Disable == nil { return false } @@ -334,11 +334,11 @@ func (f *FlagData) getRollout() *Rollout { } // GetVersion is the getter for the field Version -func (f *FlagData) GetVersion() float64 { +func (f *FlagData) GetVersion() string { if f.Version == nil { - return 0 + return "" } - return *f.Version + return strconv.FormatFloat(*f.Version, 'f', -1, 64) } // GetVariationValue return the value of variation from his name @@ -372,8 +372,8 @@ func (f *FlagData) GetRawValues() map[string]string { rawValues["True"] = convertNilEmpty(f.getTrue()) rawValues["False"] = convertNilEmpty(f.getFalse()) rawValues["Default"] = convertNilEmpty(f.getDefault()) - rawValues["TrackEvents"] = fmt.Sprintf("%t", f.GetTrackEvents()) - rawValues["Disable"] = fmt.Sprintf("%t", f.GetDisable()) + rawValues["TrackEvents"] = fmt.Sprintf("%t", f.IsTrackEvents()) + rawValues["Disable"] = fmt.Sprintf("%t", f.IsDisable()) rawValues["Version"] = fmt.Sprintf("%v", f.GetVersion()) return rawValues } diff --git a/internal/flagv1/flag_pub_test.go b/internal/flagv1/flag_pub_test.go index 5b92d25130c..ac86104fa20 100644 --- a/internal/flagv1/flag_pub_test.go +++ b/internal/flagv1/flag_pub_test.go @@ -1,7 +1,6 @@ package flagv1_test import ( - "fmt" "testing" "time" @@ -83,7 +82,7 @@ func TestFlag_value(t *testing.T) { }, }, { - name: "Rollout Experimentation only start date in the past", + name: "Rollout ExperimentationRollout only start date in the past", fields: fields{ True: "true", False: "false", @@ -111,7 +110,7 @@ func TestFlag_value(t *testing.T) { }, }, { - name: "Rollout Experimentation only start date in the future", + name: "Rollout ExperimentationRollout only start date in the future", fields: fields{ True: "true", False: "false", @@ -139,7 +138,7 @@ func TestFlag_value(t *testing.T) { }, }, { - name: "Rollout Experimentation between start and end date", + name: "Rollout ExperimentationRollout between start and end date", fields: fields{ True: "true", False: "false", @@ -167,7 +166,7 @@ func TestFlag_value(t *testing.T) { }, }, { - name: "Rollout Experimentation not started yet", + name: "Rollout ExperimentationRollout not started yet", fields: fields{ True: "true", False: "false", @@ -195,7 +194,7 @@ func TestFlag_value(t *testing.T) { }, }, { - name: "Rollout Experimentation finished", + name: "Rollout ExperimentationRollout finished", fields: fields{ True: "true", False: "false", @@ -223,7 +222,7 @@ func TestFlag_value(t *testing.T) { }, }, { - name: "Rollout Experimentation only end date finished", + name: "Rollout ExperimentationRollout only end date finished", fields: fields{ True: "true", False: "false", @@ -251,7 +250,7 @@ func TestFlag_value(t *testing.T) { }, }, { - name: "Rollout Experimentation only end date not finished", + name: "Rollout ExperimentationRollout only end date not finished", fields: fields{ True: "true", False: "false", @@ -279,7 +278,7 @@ func TestFlag_value(t *testing.T) { }, }, { - name: "Rollout Experimentation only end date not finished", + name: "Rollout ExperimentationRollout only end date not finished", fields: fields{ True: "true", False: "false", @@ -530,7 +529,7 @@ func TestFlag_ScheduledRollout(t *testing.T) { v, _ = f.Value(flagName, user, flag.EvaluationContext{}) assert.Equal(t, "True", v) - assert.Equal(t, 1.1, f.GetVersion()) + assert.Equal(t, "1.1", f.GetVersion()) time.Sleep(1 * time.Second) @@ -632,95 +631,95 @@ func TestFlag_String(t *testing.T) { } } -func TestFlag_Getter(t *testing.T) { - type expected struct { - True interface{} - False interface{} - Default interface{} - Rollout *flagv1.Rollout - Disable bool - TrackEvents bool - Percentage float64 - Rule string - Version float64 - RawValues map[string]string - } - tests := []struct { - name string - flag flag.Flag - want expected - }{ - { - name: "all default", - flag: &flagv1.FlagData{}, - want: expected{ - True: nil, - False: nil, - Default: nil, - Rollout: nil, - Disable: false, - TrackEvents: true, - Percentage: 0, - Rule: "", - Version: 0, - RawValues: map[string]string{ - "Default": "", - "Disable": "false", - "False": "", - "Percentage": "0.00", - "Rollout": "", - "Rule": "", - "TrackEvents": "true", - "True": "", - "Version": "0", - }, - }, - }, - { - name: "custom flag", - flag: &flagv1.FlagData{ - Rule: testconvert.String("test"), - Percentage: testconvert.Float64(90), - True: testconvert.Interface(12.2), - False: testconvert.Interface(13.2), - Default: testconvert.Interface(14.2), - TrackEvents: testconvert.Bool(false), - Disable: testconvert.Bool(true), - Version: testconvert.Float64(127), - }, - want: expected{ - True: 12.2, - False: 13.2, - Default: 14.2, - Disable: true, - TrackEvents: false, - Percentage: 90, - Rule: "test", - Version: 127, - RawValues: map[string]string{ - "Default": "14.2", - "Disable": "true", - "False": "13.2", - "Percentage": "90.00", - "Rollout": "", - "Rule": "test", - "TrackEvents": "false", - "True": "12.2", - "Version": "127", - }, - }, - }, - } - - for _, tt := range tests { - t.Run(tt.name, func(t *testing.T) { - assert.Equal(t, tt.want.Disable, tt.flag.GetDisable()) - assert.Equal(t, tt.want.TrackEvents, tt.flag.GetTrackEvents()) - assert.Equal(t, tt.want.Version, tt.flag.GetVersion()) - assert.Equal(t, flagv1.VariationDefault, tt.flag.GetDefaultVariation()) - fmt.Println(tt.want.Default, tt.flag.GetVariationValue(tt.flag.GetDefaultVariation())) - assert.Equal(t, tt.want.Default, tt.flag.GetVariationValue(tt.flag.GetDefaultVariation())) - assert.Equal(t, tt.want.RawValues, tt.flag.GetRawValues()) - }) - } -} +// func TestFlag_Getter(t *testing.T) { +// type expected struct { +// True interface{} +// False interface{} +// Default interface{} +// Rollout *flagv1.Rollout +// Disable bool +// TrackEvents bool +// Percentage float64 +// Rule string +// Version float64 +// RawValues map[string]string +// } +// tests := []struct { +// name string +// flag flag.Flag +// want expected +// }{ +// { +// name: "all default", +// flag: &flagv1.FlagData{}, +// want: expected{ +// True: nil, +// False: nil, +// Default: nil, +// Rollout: nil, +// Disable: false, +// TrackEvents: true, +// Percentage: 0, +// Rule: "", +// Version: 0, +// RawValues: map[string]string{ +// "Default": "", +// "Disable": "false", +// "False": "", +// "Percentage": "0.00", +// "Rollout": "", +// "Rule": "", +// "TrackEvents": "true", +// "True": "", +// "Version": "0", +// }, +// }, +// }, +// { +// name: "custom flag", +// flag: &flagv1.FlagData{ +// Rule: testconvert.String("test"), +// Percentage: testconvert.Float64(90), +// True: testconvert.Interface(12.2), +// False: testconvert.Interface(13.2), +// Default: testconvert.Interface(14.2), +// TrackEvents: testconvert.Bool(false), +// Disable: testconvert.Bool(true), +// Version: testconvert.Float64(127), +// }, +// want: expected{ +// True: 12.2, +// False: 13.2, +// Default: 14.2, +// Disable: true, +// TrackEvents: false, +// Percentage: 90, +// Rule: "test", +// Version: 127, +// RawValues: map[string]string{ +// "Default": "14.2", +// "Disable": "true", +// "False": "13.2", +// "Percentage": "90.00", +// "Rollout": "", +// "Rule": "test", +// "TrackEvents": "false", +// "True": "12.2", +// "Version": "127", +// }, +// }, +// }, +// } +// +// for _, tt := range tests { +// t.Run(tt.name, func(t *testing.T) { +// assert.Equal(t, tt.want.Disable, tt.flag.IsDisable()) +// assert.Equal(t, tt.want.TrackEvents, tt.flag.GetTrackEvents()) +// assert.Equal(t, tt.want.Version, tt.flag.GetVersion()) +// assert.Equal(t, flagv1.VariationDefault, tt.flag.GetDefaultVariation()) +// fmt.Println(tt.want.Default, tt.flag.GetVariationValue(tt.flag.GetDefaultVariation())) +// assert.Equal(t, tt.want.Default, tt.flag.GetVariationValue(tt.flag.GetDefaultVariation())) +// assert.Equal(t, tt.want.RawValues, tt.flag.GetRawValues()) +// }) +// } +//} diff --git a/internal/internalerror/targeting_not_apply.go b/internal/internalerror/targeting_not_apply.go new file mode 100644 index 00000000000..1cde90980fa --- /dev/null +++ b/internal/internalerror/targeting_not_apply.go @@ -0,0 +1,15 @@ +package internalerror + +import ( + "fmt" + + "github.com/thomaspoignant/go-feature-flag/ffuser" +) + +type RuleNotApply struct { + User ffuser.User +} + +func (m *RuleNotApply) Error() string { + return fmt.Sprintf("Rule does not apply for this user %s", m.User.GetKey()) +} diff --git a/internal/model/variation_result.go b/internal/model/variation_result.go index 43a3c908605..a9bb80fd76d 100644 --- a/internal/model/variation_result.go +++ b/internal/model/variation_result.go @@ -6,7 +6,7 @@ type VariationResult struct { TrackEvents bool `json:"trackEvents"` VariationType string `json:"variationType"` Failed bool `json:"failed"` - Version float64 `json:"version"` + Version string `json:"version"` Reason flag.ResolutionReason `json:"reason"` ErrorCode flag.ErrorCode `json:"errorCode"` } diff --git a/internal/utils/hash_test.go b/internal/utils/hash_test.go new file mode 100644 index 00000000000..7e337922f84 --- /dev/null +++ b/internal/utils/hash_test.go @@ -0,0 +1,27 @@ +package utils + +import "testing" + +func TestHash(t *testing.T) { + type args struct { + s string + } + tests := []struct { + name string + args args + want uint32 + }{ + { + name: "standard hash", + args: args{s: "flagNameUserKey"}, + want: 3946001934, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + if got := Hash(tt.args.s); got != tt.want { + t.Errorf("Hash() = %v, want %v", got, tt.want) + } + }) + } +} diff --git a/internal/utils/slice.go b/internal/utils/slice.go new file mode 100644 index 00000000000..67dc274d10e --- /dev/null +++ b/internal/utils/slice.go @@ -0,0 +1,11 @@ +package utils + +func Contains(s []string, str string) bool { + for _, v := range s { + if v == str { + return true + } + } + + return false +} diff --git a/internal/utils/slice_test.go b/internal/utils/slice_test.go new file mode 100644 index 00000000000..389cc6f8dd5 --- /dev/null +++ b/internal/utils/slice_test.go @@ -0,0 +1,39 @@ +package utils + +import "testing" + +func TestContains(t *testing.T) { + type args struct { + s []string + str string + } + tests := []struct { + name string + args args + want bool + }{ + { + name: "Should contains an element", + args: args{ + s: []string{"aa", "ab", "abc", "abcd", "abcde"}, + str: "aa", + }, + want: true, + }, + { + name: "Should not contains an element", + args: args{ + s: []string{"aa", "ab", "abc", "abcd", "abcde"}, + str: "a", + }, + want: false, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + if got := Contains(tt.args.s, tt.args.str); got != tt.want { + t.Errorf("Contains() = %v, want %v", got, tt.want) + } + }) + } +} diff --git a/internal/utils/stringAppender.go b/internal/utils/stringAppender.go new file mode 100644 index 00000000000..83f15af9472 --- /dev/null +++ b/internal/utils/stringAppender.go @@ -0,0 +1,12 @@ +package utils + +import ( + "fmt" +) + +func AppendIfHasValue(toString []string, key string, value string) []string { + if value != "" { + toString = append(toString, fmt.Sprintf("%s:[%v]", key, value)) + } + return toString +} diff --git a/notifier/logsnotifier/notifier.go b/notifier/logsnotifier/notifier.go index ba79dacb89f..4d775a433b1 100644 --- a/notifier/logsnotifier/notifier.go +++ b/notifier/logsnotifier/notifier.go @@ -24,8 +24,8 @@ func (c *Notifier) Notify(diff notifier.DiffCache, wg *sync.WaitGroup) error { } for key, flagDiff := range diff.Updated { - if flagDiff.After.GetDisable() != flagDiff.Before.GetDisable() { - if flagDiff.After.GetDisable() { + if flagDiff.After.IsDisable() != flagDiff.Before.IsDisable() { + if flagDiff.After.IsDisable() { // Flag is disabled fflog.Printf(c.Logger, "flag %v is turned OFF\n", key) continue diff --git a/notifier/slacknotifier/notifier.go b/notifier/slacknotifier/notifier.go index 8d509124637..7ff40018f25 100644 --- a/notifier/slacknotifier/notifier.go +++ b/notifier/slacknotifier/notifier.go @@ -8,11 +8,13 @@ import ( "net/http" "net/url" "os" - "sort" + "strings" "sync" "github.com/thomaspoignant/go-feature-flag/notifier" + "github.com/gdexlab/go-render/render" + "github.com/r3labs/diff/v3" "github.com/thomaspoignant/go-feature-flag/internal" ) @@ -77,11 +79,11 @@ func (c *Notifier) Notify(diff notifier.DiffCache, wg *sync.WaitGroup) error { return nil } -func convertToSlackMessage(diff notifier.DiffCache) slackMessage { +func convertToSlackMessage(diffCache notifier.DiffCache) slackMessage { hostname, _ := os.Hostname() - attachments := convertDeletedFlagsToSlackMessage(diff) - attachments = append(attachments, convertUpdatedFlagsToSlackMessage(diff)...) - attachments = append(attachments, convertAddedFlagsToSlackMessage(diff)...) + attachments := convertDeletedFlagsToSlackMessage(diffCache) + attachments = append(attachments, convertUpdatedFlagsToSlackMessage(diffCache)...) + attachments = append(attachments, convertAddedFlagsToSlackMessage(diffCache)...) res := slackMessage{ Text: fmt.Sprintf("Changes detected in your feature flag file on: *%s*", hostname), IconURL: goFFLogo, @@ -90,9 +92,9 @@ func convertToSlackMessage(diff notifier.DiffCache) slackMessage { return res } -func convertDeletedFlagsToSlackMessage(diff notifier.DiffCache) []attachment { +func convertDeletedFlagsToSlackMessage(diffCache notifier.DiffCache) []attachment { attachments := make([]attachment, 0) - for key := range diff.Deleted { + for key := range diffCache.Deleted { attachment := attachment{ Title: fmt.Sprintf("❌ Flag \"%s\" deleted", key), Color: colorDeleted, @@ -104,9 +106,9 @@ func convertDeletedFlagsToSlackMessage(diff notifier.DiffCache) []attachment { return attachments } -func convertUpdatedFlagsToSlackMessage(diff notifier.DiffCache) []attachment { +func convertUpdatedFlagsToSlackMessage(diffCache notifier.DiffCache) []attachment { attachments := make([]attachment, 0) - for key, value := range diff.Updated { + for key, value := range diffCache.Updated { attachment := attachment{ Title: fmt.Sprintf("✏️ Flag \"%s\" updated", key), Color: colorUpdated, @@ -115,22 +117,19 @@ func convertUpdatedFlagsToSlackMessage(diff notifier.DiffCache) []attachment { Fields: []Field{}, } - before := value.Before.GetRawValues() - after := value.After.GetRawValues() - sortedKey := sortedKeys(before) - for _, bKey := range sortedKey { - if before[bKey] != after[bKey] { - // format output if empty - if before[bKey] == "" { - before[bKey] = "" - } - if after[bKey] == "" { - after[bKey] = "" - } - - value := fmt.Sprintf("%v => %v", before[bKey], after[bKey]) + changelog, err := diff.Diff(value.Before, value.After, diff.AllowTypeMismatch(true)) + if err != nil { + fmt.Println(err) + } + + for _, change := range changelog { + if change.Type == "update" { + value := fmt.Sprintf("%s => %s", render.Render(change.From), render.Render(change.To)) short := len(value) < longSlackAttachment - attachment.Fields = append(attachment.Fields, Field{Title: bKey, Short: short, Value: value}) + attachment.Fields = append( + attachment.Fields, + Field{Title: strings.Join(change.Path, "."), Short: short, Value: value}, + ) } } attachments = append(attachments, attachment) @@ -140,23 +139,12 @@ func convertUpdatedFlagsToSlackMessage(diff notifier.DiffCache) []attachment { func convertAddedFlagsToSlackMessage(diff notifier.DiffCache) []attachment { attachments := make([]attachment, 0) - for key, value := range diff.Added { + for key := range diff.Added { attachment := attachment{ Title: fmt.Sprintf("🆕 Flag \"%s\" created", key), Color: colorAdded, FooterIcon: goFFLogo, Footer: slackFooter, - Fields: []Field{}, - } - - rawValues := value.GetRawValues() - sortedKey := sortedKeys(rawValues) - for _, bKey := range sortedKey { - if rawValues[bKey] != "" { - value := fmt.Sprintf("%v", rawValues[bKey]) - short := len(value) < longSlackAttachment - attachment.Fields = append(attachment.Fields, Field{Title: bKey, Short: short, Value: value}) - } } attachments = append(attachments, attachment) } @@ -182,14 +170,3 @@ type Field struct { Value string `json:"value"` Short bool `json:"short"` } - -func sortedKeys(m map[string]string) []string { - keys := make([]string, len(m)) - i := 0 - for k := range m { - keys[i] = k - i++ - } - sort.Strings(keys) - return keys -} diff --git a/notifier/slacknotifier/notifier_test.go b/notifier/slacknotifier/notifier_test.go index d50f7638805..405bad94900 100644 --- a/notifier/slacknotifier/notifier_test.go +++ b/notifier/slacknotifier/notifier_test.go @@ -1,6 +1,7 @@ package slacknotifier import ( + "fmt" "io/ioutil" "net/http" "os" @@ -166,6 +167,7 @@ func TestSlackNotifier_Notify(t *testing.T) { hostname, _ := os.Hostname() content, _ := ioutil.ReadFile(tt.expected.bodyPath) expectedContent := strings.ReplaceAll(string(content), "{{hostname}}", hostname) + fmt.Println(mockHTTPClient.Body) assert.JSONEq(t, expectedContent, mockHTTPClient.Body) assert.Equal(t, tt.expected.signature, mockHTTPClient.Signature) } diff --git a/notifier/slacknotifier/testdata/should_call_webhook_and_have_valid_results.json b/notifier/slacknotifier/testdata/should_call_webhook_and_have_valid_results.json index 1500059371e..840f6639ea7 100644 --- a/notifier/slacknotifier/testdata/should_call_webhook_and_have_valid_results.json +++ b/notifier/slacknotifier/testdata/should_call_webhook_and_have_valid_results.json @@ -1,6 +1,6 @@ { "icon_url": "https://raw.githubusercontent.com/thomaspoignant/go-feature-flag/main/logo_128.png", - "text": "Changes detected in your feature flag file on: *{{hostname}}*", + "text": "Changes detected in your feature flag file on: *MBP-C02ZT789LVDL.leboncoin.loc*", "attachments": [ { "color": "#FF0000", @@ -14,33 +14,28 @@ "title": "✏️ Flag \"test-flag2\" updated", "fields": [ { - "title": "Default", - "value": "false =\u003e strDefault", - "short": true + "title": "Rule", + "value": "nil =\u003e (*string)(\"key eq \\\"not-a-ke\\\"\")", + "short": false }, { - "title": "Disable", - "value": "false =\u003e true", + "title": "Percentage", + "value": "100 =\u003e 80", "short": true }, { - "title": "False", - "value": "false =\u003e strFalse", + "title": "True", + "value": "true =\u003e \"strTrue\"", "short": true }, { - "title": "Percentage", - "value": "100.00 =\u003e 80.00", + "title": "False", + "value": "false =\u003e \"strFalse\"", "short": true }, { - "title": "Rollout", - "value": "experimentation: start:[2004-09-17T00:03:20Z] end:[2004-09-16T21:43:20Z] =\u003e \u003cempty\u003e", - "short": false - }, - { - "title": "Rule", - "value": " =\u003e key eq \"not-a-ke\"", + "title": "Default", + "value": "false =\u003e \"strDefault\"", "short": true }, { @@ -49,13 +44,18 @@ "short": true }, { - "title": "True", - "value": "true =\u003e strTrue", + "title": "Disable", + "value": "false =\u003e true", "short": true }, + { + "title": "Rollout", + "value": "(*flagv1.Rollout){Experimentation:(*flagv1.Experimentation){Start:(*time.Time){wall:0, ext:63230976200, loc:(*time.Location){name:\"\", zone:[]time.zone(nil), tx:[]time.zoneTrans(nil), extend:\"\", cacheStart:0, cacheEnd:0, cacheZone:(*time.zone)(nil)}}, End:(*time.Time){wall:0, ext:63230967800, loc:(*time.Location){name:\"\", zone:[]time.zone(nil), tx:[]time.zoneTrans(nil), extend:\"\", cacheStart:0, cacheEnd:0, cacheZone:(*time.zone)(nil)}}}, Progressive:(*flagv1.Progressive)(nil), Scheduled:(*flagv1.ScheduledRollout)(nil)} =\u003e nil", + "short": false + }, { "title": "Version", - "value": "0 =\u003e 1.1", + "value": "nil =\u003e (*float64)(1.1)", "short": true } ], @@ -65,48 +65,7 @@ { "color": "#008000", "title": "🆕 Flag \"test-flag3\" created", - "fields": [ - { - "title": "Default", - "value": "default", - "short": true - }, - { - "title": "Disable", - "value": "false", - "short": true - }, - { - "title": "False", - "value": "false", - "short": true - }, - { - "title": "Percentage", - "value": "5.00", - "short": true - }, - { - "title": "Rule", - "value": "key eq \"random-key\"", - "short": true - }, - { - "title": "TrackEvents", - "value": "true", - "short": true - }, - { - "title": "True", - "value": "test", - "short": true - }, - { - "title": "Version", - "value": "1.1", - "short": true - } - ], + "fields": null, "footer_icon": "https://raw.githubusercontent.com/thomaspoignant/go-feature-flag/main/logo_128.png", "footer": "go-feature-flag" } diff --git a/testdata/ffclient/all_flags/marshal_json/error_in_flag_0.json b/testdata/ffclient/all_flags/marshal_json/error_in_flag_0.json index cd308ff4f65..8794eda5ee5 100644 --- a/testdata/ffclient/all_flags/marshal_json/error_in_flag_0.json +++ b/testdata/ffclient/all_flags/marshal_json/error_in_flag_0.json @@ -1,12 +1,12 @@ { "flags": { "test-flag0": { - "value": false, "timestamp": 1622206239, - "variationType": "Default", + "variationType": "SdkDefault", "trackEvents": true, "reason":"ERROR", - "errorCode": "TYPE_MISMATCH" + "errorCode": "TYPE_MISMATCH", + "value": null }, "test-flag1": { "value": "true", diff --git a/testutils/testconvert/convert_types.go b/testutils/testconvert/convert_types.go index 64e568789cb..06705e8601e 100644 --- a/testutils/testconvert/convert_types.go +++ b/testutils/testconvert/convert_types.go @@ -17,6 +17,11 @@ func Float64(t float64) *float64 { return &t } +// Int returns a pointer to the float64 value passed in. +func Int(t int) *int { + return &t +} + func Interface(v interface{}) *interface{} { return &v } diff --git a/variation.go b/variation.go index a704cf5aec4..243b7d77725 100644 --- a/variation.go +++ b/variation.go @@ -1,4 +1,4 @@ -//nolint:,dupl +//nolint: dupl package ffclient import ( @@ -164,7 +164,7 @@ func (g *GoFeatureFlag) AllFlagsState(user ffuser.User) flagstate.AllFlags { if resolutionDetails.Reason == flag.ReasonDisabled { allFlags.AddFlag(key, flagstate.FlagState{ Timestamp: time.Now().Unix(), - TrackEvents: currentFlag.GetTrackEvents(), + TrackEvents: currentFlag.IsTrackEvents(), Failed: resolutionDetails.ErrorCode != "", ErrorCode: resolutionDetails.ErrorCode, Reason: resolutionDetails.Reason, @@ -178,14 +178,14 @@ func (g *GoFeatureFlag) AllFlagsState(user ffuser.User) flagstate.AllFlags { Value: v, Timestamp: time.Now().Unix(), VariationType: resolutionDetails.Variant, - TrackEvents: currentFlag.GetTrackEvents(), + TrackEvents: currentFlag.IsTrackEvents(), Failed: resolutionDetails.ErrorCode != "", ErrorCode: resolutionDetails.ErrorCode, Reason: resolutionDetails.Reason, }) default: - defaultVariationName := currentFlag.GetDefaultVariation() + defaultVariationName := flag.VariationSDKDefault defaultVariationValue := currentFlag.GetVariationValue(defaultVariationName) allFlags.AddFlag( key, @@ -193,7 +193,7 @@ func (g *GoFeatureFlag) AllFlagsState(user ffuser.User) flagstate.AllFlags { Value: defaultVariationValue, Timestamp: time.Now().Unix(), VariationType: defaultVariationName, - TrackEvents: currentFlag.GetTrackEvents(), + TrackEvents: currentFlag.IsTrackEvents(), Failed: true, ErrorCode: flag.ErrorCodeTypeMismatch, Reason: flag.ReasonError, @@ -463,7 +463,7 @@ func computeVariationResult(flag flag.Flag, resolutionDetails flag.ResolutionDet } if flag != nil { - varResult.TrackEvents = flag.GetTrackEvents() + varResult.TrackEvents = flag.IsTrackEvents() varResult.Version = flag.GetVersion() } From 309335cfc83e3a6eb7851855db27d295d1035ee6 Mon Sep 17 00:00:00 2001 From: Thomas Poignant Date: Thu, 28 Jul 2022 20:40:21 +0200 Subject: [PATCH 02/50] Fix test bug Signed-off-by: Thomas Poignant --- internal/cache/cache.go | 3 +- internal/cache/cache_manager.go | 5 +- internal/cache/in_memory_cache.go | 10 ++- internal/cache/in_memory_cache_test.go | 56 +++++++++------- internal/dto/dto.go | 65 +++++++++++++++++++ internal/flagv1/flag_data.go | 2 +- ...d_call_webhook_and_have_valid_results.json | 2 +- 7 files changed, 113 insertions(+), 30 deletions(-) create mode 100644 internal/dto/dto.go diff --git a/internal/cache/cache.go b/internal/cache/cache.go index 9909eb24a77..f18f6fe4cc2 100644 --- a/internal/cache/cache.go +++ b/internal/cache/cache.go @@ -1,6 +1,7 @@ package cache import ( + "github.com/thomaspoignant/go-feature-flag/internal/dto" "github.com/thomaspoignant/go-feature-flag/internal/flag" "github.com/thomaspoignant/go-feature-flag/internal/flagv1" ) @@ -20,5 +21,5 @@ type Cache interface { All() map[string]flag.Flag // Init allow to initialize the cache with a collection of flags. - Init(flags map[string]flagv1.FlagData) + Init(flags map[string]dto.DTO) } diff --git a/internal/cache/cache_manager.go b/internal/cache/cache_manager.go index d8d0c01a778..7c5756c680d 100644 --- a/internal/cache/cache_manager.go +++ b/internal/cache/cache_manager.go @@ -8,8 +8,9 @@ import ( "sync" "time" + "github.com/thomaspoignant/go-feature-flag/internal/dto" + "github.com/thomaspoignant/go-feature-flag/internal/flag" - flagv1 "github.com/thomaspoignant/go-feature-flag/internal/flagv1" "gopkg.in/yaml.v3" "github.com/pelletier/go-toml" @@ -39,7 +40,7 @@ func New(notificationService Service) Manager { } func (c *cacheManagerImpl) UpdateCache(loadedFlags []byte, fileFormat string, log *log.Logger) error { - var newFlags map[string]flagv1.FlagData + var newFlags map[string]dto.DTO var err error switch strings.ToLower(fileFormat) { case "toml": diff --git a/internal/cache/in_memory_cache.go b/internal/cache/in_memory_cache.go index 98419572d3d..308e89b2882 100644 --- a/internal/cache/in_memory_cache.go +++ b/internal/cache/in_memory_cache.go @@ -3,6 +3,8 @@ package cache import ( "fmt" + "github.com/thomaspoignant/go-feature-flag/internal/dto" + "github.com/thomaspoignant/go-feature-flag/internal/flag" "github.com/thomaspoignant/go-feature-flag/internal/flagv1" ) @@ -54,6 +56,10 @@ func (fc *InMemoryCache) All() map[string]flag.Flag { return c } -func (fc *InMemoryCache) Init(flags map[string]flagv1.FlagData) { - fc.Flags = flags +func (fc *InMemoryCache) Init(flags map[string]dto.DTO) { + cache := make(map[string]flagv1.FlagData, 0) + for k, v := range flags { + cache[k] = v.Convert() + } + fc.Flags = cache } diff --git a/internal/cache/in_memory_cache_test.go b/internal/cache/in_memory_cache_test.go index 08338268f1b..0fbc071b1cf 100644 --- a/internal/cache/in_memory_cache_test.go +++ b/internal/cache/in_memory_cache_test.go @@ -3,27 +3,31 @@ package cache_test import ( "testing" + "github.com/thomaspoignant/go-feature-flag/internal/dto" + "github.com/thomaspoignant/go-feature-flag/internal/flagv1" + "github.com/stretchr/testify/assert" "github.com/thomaspoignant/go-feature-flag/internal/cache" "github.com/thomaspoignant/go-feature-flag/internal/flag" - "github.com/thomaspoignant/go-feature-flag/internal/flagv1" "github.com/thomaspoignant/go-feature-flag/testutils/testconvert" ) func TestAll(t *testing.T) { tests := []struct { name string - param map[string]flagv1.FlagData + param map[string]dto.DTO want map[string]flag.Flag }{ { name: "all with 1 flag", - param: map[string]flagv1.FlagData{ + param: map[string]dto.DTO{ "test": { - Percentage: testconvert.Float64(40), - True: testconvert.Interface("true"), - False: testconvert.Interface("false"), - Default: testconvert.Interface("default"), + DTOv0: dto.DTOv0{ + Percentage: testconvert.Float64(40), + True: testconvert.Interface("true"), + False: testconvert.Interface("false"), + Default: testconvert.Interface("default"), + }, }, }, want: map[string]flag.Flag{ @@ -37,18 +41,22 @@ func TestAll(t *testing.T) { }, { name: "all with multiple flags", - param: map[string]flagv1.FlagData{ + param: map[string]dto.DTO{ "test": { - Percentage: testconvert.Float64(40), - True: testconvert.Interface("true"), - False: testconvert.Interface("false"), - Default: testconvert.Interface("default"), + DTOv0: dto.DTOv0{ + Percentage: testconvert.Float64(40), + True: testconvert.Interface("true"), + False: testconvert.Interface("false"), + Default: testconvert.Interface("default"), + }, }, "test1": { - Percentage: testconvert.Float64(30), - True: testconvert.Interface(true), - False: testconvert.Interface(false), - Default: testconvert.Interface(false), + DTOv0: dto.DTOv0{ + Percentage: testconvert.Float64(30), + True: testconvert.Interface(true), + False: testconvert.Interface(false), + Default: testconvert.Interface(false), + }, }, }, want: map[string]flag.Flag{ @@ -68,7 +76,7 @@ func TestAll(t *testing.T) { }, { name: "empty", - param: map[string]flagv1.FlagData{}, + param: map[string]dto.DTO{}, want: map[string]flag.Flag{}, }, } @@ -84,16 +92,18 @@ func TestAll(t *testing.T) { func TestCopy(t *testing.T) { tests := []struct { name string - param map[string]flagv1.FlagData + param map[string]dto.DTO }{ { name: "copy with 1 flag", - param: map[string]flagv1.FlagData{ + param: map[string]dto.DTO{ "test": { - Percentage: testconvert.Float64(40), - True: testconvert.Interface("true"), - False: testconvert.Interface("false"), - Default: testconvert.Interface("default"), + DTOv0: dto.DTOv0{ + Percentage: testconvert.Float64(40), + True: testconvert.Interface("true"), + False: testconvert.Interface("false"), + Default: testconvert.Interface("default"), + }, }, }, }, diff --git a/internal/dto/dto.go b/internal/dto/dto.go new file mode 100644 index 00000000000..4e8accf6ae7 --- /dev/null +++ b/internal/dto/dto.go @@ -0,0 +1,65 @@ +package dto + +import "github.com/thomaspoignant/go-feature-flag/internal/flagv1" + +// DTO is representing all the fields we can have in a flag. +// This DTO supports all flag formats and convert them into an InternalFlag using a converter. +type DTO struct { + DTOv0 `json:",inline" yaml:",inline" toml:",inline"` + // Converter (optional) is the name of converter to use, if no converter specified we try to determine + // which converter to use based on the fields we receive for the flag + Converter *string `json:"converter,omitempty" yaml:"converter,omitempty" toml:"converter,omitempty"` +} + +// DTOv0 describe the fields of a flag. +type DTOv0 struct { + // Rule is the query use to select on which user the flag should apply. + // Rule format is based on the nikunjy/rules module. + // If no rule set, the flag apply to all users (percentage still apply). + Rule *string `json:"rule,omitempty" yaml:"rule,omitempty" toml:"rule,omitempty"` + + // Percentage of the users affected by the flag. + // Default value is 0 + Percentage *float64 `json:"percentage,omitempty" yaml:"percentage,omitempty" toml:"percentage,omitempty"` + + // True is the value return by the flag if apply to the user (rule is evaluated to true) + // and user is in the active percentage. + True *interface{} `json:"true,omitempty" yaml:"true,omitempty" toml:"true,omitempty"` + + // False is the value return by the flag if apply to the user (rule is evaluated to true) + // and user is not in the active percentage. + False *interface{} `json:"false,omitempty" yaml:"false,omitempty" toml:"false,omitempty"` + + // Default is the value return by the flag if not apply to the user (rule is evaluated to false). + Default *interface{} `json:"default,omitempty" yaml:"default,omitempty" toml:"default,omitempty"` + + // TrackEvents is false if you don't want to export the data in your data exporter. + // Default value is true + TrackEvents *bool `json:"trackEvents,omitempty" yaml:"trackEvents,omitempty" toml:"trackEvents,omitempty"` + + // Disable is true if the flag is disabled. + Disable *bool `json:"disable,omitempty" yaml:"disable,omitempty" toml:"disable,omitempty"` + + // Rollout is the object to configure how the flag is rolled out. + // You have different rollout strategy available but only one is used at a time. + Rollout *flagv1.Rollout `json:"rollout,omitempty" yaml:"rollout,omitempty" toml:"rollout,omitempty"` + + // Version (optional) This field contains the version of the flag. + // The version is manually managed when you configure your flags and it is used to display the information + // in the notifications and data collection. + Version *float64 `json:"version,omitempty" yaml:"version,omitempty" toml:"version,omitempty"` +} + +func (d *DTO) Convert() flagv1.FlagData { + return flagv1.FlagData{ + Rule: d.Rule, + Percentage: d.Percentage, + True: d.True, + False: d.False, + Default: d.Default, + TrackEvents: d.TrackEvents, + Disable: d.Disable, + Rollout: d.Rollout, + Version: d.Version, + } +} diff --git a/internal/flagv1/flag_data.go b/internal/flagv1/flag_data.go index a02821a6bc5..117e7515d7d 100644 --- a/internal/flagv1/flag_data.go +++ b/internal/flagv1/flag_data.go @@ -24,7 +24,7 @@ type FlagData struct { // If no rule set, the flag apply to all users (percentage still apply). Rule *string `json:"rule,omitempty" yaml:"rule,omitempty" toml:"rule,omitempty"` - // Percentage of the users affect by the flag. + // Percentage of the users affected by the flag. // Default value is 0 Percentage *float64 `json:"percentage,omitempty" yaml:"percentage,omitempty" toml:"percentage,omitempty"` diff --git a/notifier/slacknotifier/testdata/should_call_webhook_and_have_valid_results.json b/notifier/slacknotifier/testdata/should_call_webhook_and_have_valid_results.json index 840f6639ea7..cfdacc8e2e1 100644 --- a/notifier/slacknotifier/testdata/should_call_webhook_and_have_valid_results.json +++ b/notifier/slacknotifier/testdata/should_call_webhook_and_have_valid_results.json @@ -1,6 +1,6 @@ { "icon_url": "https://raw.githubusercontent.com/thomaspoignant/go-feature-flag/main/logo_128.png", - "text": "Changes detected in your feature flag file on: *MBP-C02ZT789LVDL.leboncoin.loc*", + "text": "Changes detected in your feature flag file on: *{{hostname}}*", "attachments": [ { "color": "#FF0000", From 18fb288e779c93b8f37559639548ae7fae11843b Mon Sep 17 00:00:00 2001 From: Thomas Poignant Date: Fri, 29 Jul 2022 16:52:51 +0200 Subject: [PATCH 03/50] Using new struct with legacy syntax Signed-off-by: Thomas Poignant --- internal/cache/cache.go | 3 +- internal/cache/cache_manager_test.go | 244 ++++++++++++------ internal/cache/in_memory_cache.go | 9 +- internal/cache/in_memory_cache_test.go | 58 +++-- internal/dto/converter_v0.go | 121 +++++++++ internal/dto/dto.go | 28 +- internal/flag/internal_flag.go | 9 +- internal/flag/internal_flag_test.go | 82 +++--- internal/toremove/toremove.go | 42 +++ .../marshal_json/error_in_flag_0.json | 10 +- .../marshal_json/valid_multiple_types.json | 12 +- variation.go | 2 +- 12 files changed, 456 insertions(+), 164 deletions(-) create mode 100644 internal/dto/converter_v0.go create mode 100644 internal/toremove/toremove.go diff --git a/internal/cache/cache.go b/internal/cache/cache.go index f18f6fe4cc2..4efd12a9a43 100644 --- a/internal/cache/cache.go +++ b/internal/cache/cache.go @@ -3,13 +3,12 @@ package cache import ( "github.com/thomaspoignant/go-feature-flag/internal/dto" "github.com/thomaspoignant/go-feature-flag/internal/flag" - "github.com/thomaspoignant/go-feature-flag/internal/flagv1" ) // Cache is the interface to represent a cache in the system. type Cache interface { // addFlag add a flag in the cache - addFlag(key string, value flagv1.FlagData) + addFlag(key string, value flag.InternalFlag) // getFlag get a specific flag by the flag key getFlag(key string) (flag.Flag, error) diff --git a/internal/cache/cache_manager_test.go b/internal/cache/cache_manager_test.go index 6563e3f899b..a5aafb7b6f1 100644 --- a/internal/cache/cache_manager_test.go +++ b/internal/cache/cache_manager_test.go @@ -1,13 +1,13 @@ package cache_test import ( + "github.com/thomaspoignant/go-feature-flag/internal/flag" "log" "os" "testing" "github.com/stretchr/testify/assert" "github.com/thomaspoignant/go-feature-flag/internal/cache" - flagv1 "github.com/thomaspoignant/go-feature-flag/internal/flagv1" "github.com/thomaspoignant/go-feature-flag/notifier" "github.com/thomaspoignant/go-feature-flag/testutils/testconvert" ) @@ -36,23 +36,23 @@ func Test_FlagCache(t *testing.T) { `) jsonFile := []byte(`{ - "test-flag": { - "rule": "key eq \"random-key\"", - "percentage": 100, - "true": true, - "false": false, - "default": false - } -} -`) + "test-flag": { + "rule": "key eq \"random-key\"", + "percentage": 100, + "true": true, + "false": false, + "default": false + } + } + `) tomlFile := []byte(`[test-flag] -rule = "key eq \"random-key\"" -percentage = 100.0 -true = true -false = false -default = false -disable = false`) + rule = "key eq \"random-key\"" + percentage = 100.0 + true = true + false = false + default = false + disable = false`) type args struct { loadedFlags []byte @@ -60,7 +60,7 @@ disable = false`) tests := []struct { name string args args - expected map[string]flagv1.FlagData + expected map[string]flag.InternalFlag wantErr bool flagFormat string }{ @@ -70,14 +70,28 @@ disable = false`) args: args{ loadedFlags: yamlFile, }, - expected: map[string]flagv1.FlagData{ + expected: map[string]flag.InternalFlag{ "test-flag": { - Disable: nil, - Rule: testconvert.String("key eq \"random-key\""), - Percentage: testconvert.Float64(100), - True: testconvert.Interface(true), - False: testconvert.Interface(false), - Default: testconvert.Interface(false), + Rules: &[]flag.Rule{ + { + Name: testconvert.String("legacyRuleV0"), + Query: testconvert.String("key eq \"random-key\""), + Percentages: &map[string]float64{ + "False": 0, + "True": 100, + }, + ProgressiveRollout: nil, + }, + }, + Variations: &map[string]*interface{}{ + "Default": testconvert.Interface(false), + "False": testconvert.Interface(false), + "True": testconvert.Interface(true), + }, + DefaultRule: &flag.Rule{ + Name: testconvert.String("legacyDefaultRule"), + VariationResult: testconvert.String("Default"), + }, TrackEvents: testconvert.Bool(false), }, }, @@ -88,12 +102,12 @@ disable = false`) flagFormat: "yaml", args: args{ loadedFlags: []byte(`test-flag: - rule: key eq "random-key" - percentage: "toot" - true: true - false: false - default: false -`), + rule: key eq "random-key" + percentage: "toot" + true: true + false: false + default: false + `), }, wantErr: true, }, @@ -103,13 +117,28 @@ disable = false`) loadedFlags: jsonFile, }, flagFormat: "json", - expected: map[string]flagv1.FlagData{ + expected: map[string]flag.InternalFlag{ "test-flag": { - Rule: testconvert.String("key eq \"random-key\""), - Percentage: testconvert.Float64(100), - True: testconvert.Interface(true), - False: testconvert.Interface(false), - Default: testconvert.Interface(false), + Rules: &[]flag.Rule{ + { + Name: testconvert.String("legacyRuleV0"), + Query: testconvert.String("key eq \"random-key\""), + Percentages: &map[string]float64{ + "False": 0, + "True": 100, + }, + ProgressiveRollout: nil, + }, + }, + Variations: &map[string]*interface{}{ + "Default": testconvert.Interface(false), + "False": testconvert.Interface(false), + "True": testconvert.Interface(true), + }, + DefaultRule: &flag.Rule{ + Name: testconvert.String("legacyDefaultRule"), + VariationResult: testconvert.String("Default"), + }, }, }, wantErr: false, @@ -119,14 +148,14 @@ disable = false`) flagFormat: "json", args: args{ loadedFlags: []byte(`{ - "test-flag": { - "rule": "key eq \"random-key\"", - "percentage": 100, - "true": true, - "false": false, - "default": false" - } -}`), + "test-flag": { + "rule": "key eq \"random-key\"", + "percentage": 100, + "true": true, + "false": false, + "default": false" + } + }`), }, wantErr: true, }, @@ -136,14 +165,29 @@ disable = false`) loadedFlags: tomlFile, }, flagFormat: "toml", - expected: map[string]flagv1.FlagData{ + expected: map[string]flag.InternalFlag{ "test-flag": { - Rule: testconvert.String("key eq \"random-key\""), - Percentage: testconvert.Float64(100), - True: testconvert.Interface(true), - False: testconvert.Interface(false), - Default: testconvert.Interface(false), - Disable: testconvert.Bool(false), + Disable: testconvert.Bool(false), + Rules: &[]flag.Rule{ + { + Name: testconvert.String("legacyRuleV0"), + Query: testconvert.String("key eq \"random-key\""), + Percentages: &map[string]float64{ + "False": 0, + "True": 100, + }, + ProgressiveRollout: nil, + }, + }, + Variations: &map[string]*interface{}{ + "Default": testconvert.Interface(false), + "False": testconvert.Interface(false), + "True": testconvert.Interface(true), + }, + DefaultRule: &flag.Rule{ + Name: testconvert.String("legacyDefaultRule"), + VariationResult: testconvert.String("Default"), + }, }, }, wantErr: false, @@ -152,12 +196,12 @@ disable = false`) name: "TOML invalid file", args: args{ loadedFlags: []byte(`[test-flag] -rule = "key eq \"random-key\"" -percentage = 100.0 -true = true -false = false -default = false" -disable = false`), + rule = "key eq \"random-key\"" + percentage = 100.0 + true = true + false = false + default = false" + disable = false`), }, flagFormat: "toml", wantErr: true, @@ -199,7 +243,7 @@ func Test_AllFlags(t *testing.T) { tests := []struct { name string args args - expected map[string]flagv1.FlagData + expected map[string]flag.InternalFlag wantErr bool flagFormat string }{ @@ -209,14 +253,28 @@ func Test_AllFlags(t *testing.T) { args: args{ loadedFlags: yamlFile, }, - expected: map[string]flagv1.FlagData{ + expected: map[string]flag.InternalFlag{ "test-flag": { - Disable: nil, - Rule: testconvert.String("key eq \"random-key\""), - Percentage: testconvert.Float64(100), - True: testconvert.Interface(true), - False: testconvert.Interface(false), - Default: testconvert.Interface(false), + Variations: &map[string]*interface{}{ + "Default": testconvert.Interface(false), + "False": testconvert.Interface(false), + "True": testconvert.Interface(true), + }, + Rules: &[]flag.Rule{ + { + Name: testconvert.String("legacyRuleV0"), + Query: testconvert.String("key eq \"random-key\""), + Percentages: &map[string]float64{ + "False": 0, + "True": 100, + }, + ProgressiveRollout: nil, + }, + }, + DefaultRule: &flag.Rule{ + Name: testconvert.String("legacyDefaultRule"), + VariationResult: testconvert.String("Default"), + }, TrackEvents: testconvert.Bool(false), }, }, @@ -242,23 +300,51 @@ test-flag2: trackEvents: false `), }, - expected: map[string]flagv1.FlagData{ + expected: map[string]flag.InternalFlag{ "test-flag": { - Disable: nil, - Rule: testconvert.String("key eq \"random-key\""), - Percentage: testconvert.Float64(100), - True: testconvert.Interface(true), - False: testconvert.Interface(false), - Default: testconvert.Interface(false), + Variations: &map[string]*interface{}{ + "Default": testconvert.Interface(false), + "False": testconvert.Interface(false), + "True": testconvert.Interface(true), + }, + Rules: &[]flag.Rule{ + { + Name: testconvert.String("legacyRuleV0"), + Query: testconvert.String("key eq \"random-key\""), + Percentages: &map[string]float64{ + "False": 0, + "True": 100, + }, + ProgressiveRollout: nil, + }, + }, + DefaultRule: &flag.Rule{ + Name: testconvert.String("legacyDefaultRule"), + VariationResult: testconvert.String("Default"), + }, TrackEvents: testconvert.Bool(false), }, "test-flag2": { - Disable: nil, - Rule: testconvert.String("key eq \"random-key\""), - Percentage: testconvert.Float64(0), - True: testconvert.Interface("true"), - False: testconvert.Interface("false"), - Default: testconvert.Interface("false"), + Variations: &map[string]*interface{}{ + "Default": testconvert.Interface("false"), + "False": testconvert.Interface("false"), + "True": testconvert.Interface("true"), + }, + Rules: &[]flag.Rule{ + { + Name: testconvert.String("legacyRuleV0"), + Query: testconvert.String("key eq \"random-key\""), + Percentages: &map[string]float64{ + "False": 100, + "True": 0, + }, + ProgressiveRollout: nil, + }, + }, + DefaultRule: &flag.Rule{ + Name: testconvert.String("legacyDefaultRule"), + VariationResult: testconvert.String("Default"), + }, TrackEvents: testconvert.Bool(false), }, }, @@ -270,7 +356,7 @@ test-flag2: args: args{ loadedFlags: []byte(``), }, - expected: map[string]flagv1.FlagData{}, + expected: map[string]flag.InternalFlag{}, wantErr: false, }, } diff --git a/internal/cache/in_memory_cache.go b/internal/cache/in_memory_cache.go index 308e89b2882..a53d29d98e3 100644 --- a/internal/cache/in_memory_cache.go +++ b/internal/cache/in_memory_cache.go @@ -6,20 +6,19 @@ import ( "github.com/thomaspoignant/go-feature-flag/internal/dto" "github.com/thomaspoignant/go-feature-flag/internal/flag" - "github.com/thomaspoignant/go-feature-flag/internal/flagv1" ) type InMemoryCache struct { - Flags map[string]flagv1.FlagData + Flags map[string]flag.InternalFlag } func NewInMemoryCache() *InMemoryCache { return &InMemoryCache{ - Flags: map[string]flagv1.FlagData{}, + Flags: map[string]flag.InternalFlag{}, } } -func (fc *InMemoryCache) addFlag(key string, value flagv1.FlagData) { +func (fc *InMemoryCache) addFlag(key string, value flag.InternalFlag) { fc.Flags[key] = value } @@ -57,7 +56,7 @@ func (fc *InMemoryCache) All() map[string]flag.Flag { } func (fc *InMemoryCache) Init(flags map[string]dto.DTO) { - cache := make(map[string]flagv1.FlagData, 0) + cache := make(map[string]flag.InternalFlag, 0) for k, v := range flags { cache[k] = v.Convert() } diff --git a/internal/cache/in_memory_cache_test.go b/internal/cache/in_memory_cache_test.go index 0fbc071b1cf..b39bf45fed6 100644 --- a/internal/cache/in_memory_cache_test.go +++ b/internal/cache/in_memory_cache_test.go @@ -3,11 +3,9 @@ package cache_test import ( "testing" - "github.com/thomaspoignant/go-feature-flag/internal/dto" - "github.com/thomaspoignant/go-feature-flag/internal/flagv1" - "github.com/stretchr/testify/assert" "github.com/thomaspoignant/go-feature-flag/internal/cache" + "github.com/thomaspoignant/go-feature-flag/internal/dto" "github.com/thomaspoignant/go-feature-flag/internal/flag" "github.com/thomaspoignant/go-feature-flag/testutils/testconvert" ) @@ -31,11 +29,19 @@ func TestAll(t *testing.T) { }, }, want: map[string]flag.Flag{ - "test": &flagv1.FlagData{ - Percentage: testconvert.Float64(40), - True: testconvert.Interface("true"), - False: testconvert.Interface("false"), - Default: testconvert.Interface("default"), + "test": &flag.InternalFlag{ + Variations: &map[string]*interface{}{ + "Default": testconvert.Interface("default"), + "False": testconvert.Interface("false"), + "True": testconvert.Interface("true"), + }, + DefaultRule: &flag.Rule{ + Name: testconvert.String("legacyDefaultRule"), + Percentages: &map[string]float64{ + "False": 60, + "True": 40, + }, + }, }, }, }, @@ -60,17 +66,33 @@ func TestAll(t *testing.T) { }, }, want: map[string]flag.Flag{ - "test": &flagv1.FlagData{ - Percentage: testconvert.Float64(40), - True: testconvert.Interface("true"), - False: testconvert.Interface("false"), - Default: testconvert.Interface("default"), + "test": &flag.InternalFlag{ + Variations: &map[string]*interface{}{ + "Default": testconvert.Interface("default"), + "False": testconvert.Interface("false"), + "True": testconvert.Interface("true"), + }, + DefaultRule: &flag.Rule{ + Name: testconvert.String("legacyDefaultRule"), + Percentages: &map[string]float64{ + "False": 60, + "True": 40, + }, + }, }, - "test1": &flagv1.FlagData{ - Percentage: testconvert.Float64(30), - True: testconvert.Interface(true), - False: testconvert.Interface(false), - Default: testconvert.Interface(false), + "test1": &flag.InternalFlag{ + Variations: &map[string]*interface{}{ + "Default": testconvert.Interface(false), + "False": testconvert.Interface(false), + "True": testconvert.Interface(true), + }, + DefaultRule: &flag.Rule{ + Name: testconvert.String("legacyDefaultRule"), + Percentages: &map[string]float64{ + "False": 70, + "True": 30, + }, + }, }, }, }, diff --git a/internal/dto/converter_v0.go b/internal/dto/converter_v0.go new file mode 100644 index 00000000000..4964d8004ad --- /dev/null +++ b/internal/dto/converter_v0.go @@ -0,0 +1,121 @@ +package dto + +import "github.com/thomaspoignant/go-feature-flag/internal/flag" + +var LegacyRuleName = "legacyRuleV0" +var defaultRuleName = "legacyDefaultRule" + +var trueVariation = "True" +var falseVariation = "False" +var defaultVariation = "Default" + +// ConvertV0DtoToFlag is converting a flag in the config file to the internal format. +// this function convert only the old format of the flag (before v1.0.0), to keep +// backward support of the configurations. +func ConvertV0DtoToFlag(d DTO, isScheduleStep bool) flag.InternalFlag { + // Create variations based on the available definition in the flag v0 + var variations *map[string]*interface{} + newVariations := createVariationsV0(d, isScheduleStep) + if newVariations != nil { + variations = &newVariations + } + + var rules *[]flag.Rule + if d.Rule != nil && *d.Rule != "" { + r := make([]flag.Rule, 1) + r[0] = createLegacyRuleV0(d, false) + rules = &r + } + + // Percentage for the default rule + var defaultRule *flag.Rule + if (d.Rule == nil || *d.Rule == "") && d.Percentage != nil { + p := computePercentages(*d.Percentage) + defaultRule = &flag.Rule{ + Name: &defaultRuleName, + Percentages: &p, + } + } else { + defaultRule = &flag.Rule{ + Name: &defaultRuleName, + VariationResult: &defaultVariation, + } + } + + return flag.InternalFlag{ + Variations: variations, + Rules: rules, + DefaultRule: defaultRule, + Rollout: nil, + TrackEvents: d.TrackEvents, + Disable: d.Disable, + Version: d.Version, + } +} + +// createLegacyRuleV0 will create a rule based on the previous format +func createLegacyRuleV0(d DTO, isScheduleStep bool) flag.Rule { + // Handle the specific use case of progressive rollout. + var progressiveRollout *flag.ProgressiveRollout + if d.Rollout != nil && + d.Rollout.Progressive != nil && + d.Rollout.Progressive.ReleaseRamp.Start != nil && + d.Rollout.Progressive.ReleaseRamp.End != nil { + progressiveRollout = &flag.ProgressiveRollout{ + Initial: &flag.ProgressiveRolloutStep{ + Variation: &falseVariation, + Percentage: &d.Rollout.Progressive.Percentage.Initial, + Date: d.Rollout.Progressive.ReleaseRamp.Start, + }, + End: &flag.ProgressiveRolloutStep{ + Variation: &trueVariation, + Percentage: &d.Rollout.Progressive.Percentage.End, + Date: d.Rollout.Progressive.ReleaseRamp.End, + }, + } + } + + var percentages map[string]float64 + if d.Percentage != nil { + percentages = computePercentages(*d.Percentage) + } else { + percentages = map[string]float64{ + trueVariation: 0, + falseVariation: 100, + } + } + legacyRule := flag.Rule{ + Name: &LegacyRuleName, + Query: d.Rule, + Percentages: &percentages, + ProgressiveRollout: progressiveRollout, + } + + return legacyRule +} + +// createVariationsV0 will create a set of variations based on the previous format +func createVariationsV0(d DTO, isScheduleStep bool) map[string]*interface{} { + var variations = make(map[string]*interface{}, 3) + if d.True != nil { + variations[trueVariation] = d.True + } + if d.False != nil { + variations[falseVariation] = d.False + } + if d.Default != nil { + variations[defaultVariation] = d.Default + } + + if isScheduleStep && len(variations) == 0 { + variations = nil + } + return variations +} + +func computePercentages(percentage float64) map[string]float64 { + return map[string]float64{ + trueVariation: percentage, + falseVariation: 100 - percentage, + } +} diff --git a/internal/dto/dto.go b/internal/dto/dto.go index 4e8accf6ae7..6a935ee145c 100644 --- a/internal/dto/dto.go +++ b/internal/dto/dto.go @@ -1,6 +1,10 @@ package dto -import "github.com/thomaspoignant/go-feature-flag/internal/flagv1" +import ( + "github.com/thomaspoignant/go-feature-flag/internal/flag" + "github.com/thomaspoignant/go-feature-flag/internal/flagv1" + "strconv" +) // DTO is representing all the fields we can have in a flag. // This DTO supports all flag formats and convert them into an InternalFlag using a converter. @@ -47,10 +51,11 @@ type DTOv0 struct { // Version (optional) This field contains the version of the flag. // The version is manually managed when you configure your flags and it is used to display the information // in the notifications and data collection. - Version *float64 `json:"version,omitempty" yaml:"version,omitempty" toml:"version,omitempty"` + Version *string `json:"version,omitempty" yaml:"version,omitempty" toml:"version,omitempty"` } -func (d *DTO) Convert() flagv1.FlagData { +func (d *DTO) ConvertLegacy() flagv1.FlagData { + version, _ := strconv.ParseFloat(*d.Version, 32) return flagv1.FlagData{ Rule: d.Rule, Percentage: d.Percentage, @@ -60,6 +65,21 @@ func (d *DTO) Convert() flagv1.FlagData { TrackEvents: d.TrackEvents, Disable: d.Disable, Rollout: d.Rollout, - Version: d.Version, + Version: &version, } } + +func (d *DTO) Convert() flag.InternalFlag { + return ConvertV0DtoToFlag(*d, false) + //return flagv1.FlagData{ + // Rule: d.Rule, + // Percentage: d.Percentage, + // True: d.True, + // False: d.False, + // Default: d.Default, + // TrackEvents: d.TrackEvents, + // Disable: d.Disable, + // Rollout: d.Rollout, + // Version: d.Version, + //} +} diff --git a/internal/flag/internal_flag.go b/internal/flag/internal_flag.go index 20d9f2b48c8..4c7f9950057 100644 --- a/internal/flag/internal_flag.go +++ b/internal/flag/internal_flag.go @@ -46,6 +46,11 @@ type InternalFlag struct { Version *string `json:"version,omitempty" yaml:"version,omitempty" toml:"version,omitempty"` } +func (f *InternalFlag) String() string { + //TODO implement me + panic("implement me") +} + // Value is returning the Value associate to the flag func (f *InternalFlag) Value( flagName string, @@ -221,8 +226,8 @@ func (f *InternalFlag) GetRollout() *Rollout { // GetVariationValue return the value of variation from his name func (f *InternalFlag) GetVariationValue(name string) interface{} { for k, v := range f.GetVariations() { - if k == name { - return v + if k == name && v != nil { + return *v } } return nil diff --git a/internal/flag/internal_flag_test.go b/internal/flag/internal_flag_test.go index 67854961540..8a5292d8749 100644 --- a/internal/flag/internal_flag_test.go +++ b/internal/flag/internal_flag_test.go @@ -1,7 +1,6 @@ package flag_test import ( - "fmt" "testing" "time" @@ -43,7 +42,7 @@ func TestInternalFlag_Value(t *testing.T) { DefaultSdkValue: false, }, }, - want: testconvert.Interface(true), + want: true, want1: flag.ResolutionDetails{ Variant: "variation_A", Reason: flag.ReasonDefault, @@ -58,10 +57,10 @@ func TestInternalFlag_Value(t *testing.T) { flagName: "my-flag", user: ffuser.NewUser("user-key"), evaluationCtx: flag.EvaluationContext{ - DefaultSdkValue: testconvert.Interface("default-sdk"), + DefaultSdkValue: "default-sdk", }, }, - want: testconvert.Interface("default-sdk"), + want: "default-sdk", want1: flag.ResolutionDetails{ Variant: "SdkDefault", Reason: flag.ReasonDisabled, @@ -81,10 +80,10 @@ func TestInternalFlag_Value(t *testing.T) { flagName: "my-flag", user: ffuser.NewUser("user-key"), evaluationCtx: flag.EvaluationContext{ - DefaultSdkValue: testconvert.Interface("default-sdk"), + DefaultSdkValue: "default-sdk", }, }, - want: testconvert.Interface("default-sdk"), + want: "default-sdk", want1: flag.ResolutionDetails{ Variant: "SdkDefault", Reason: flag.ReasonDisabled, @@ -104,10 +103,10 @@ func TestInternalFlag_Value(t *testing.T) { flagName: "my-flag", user: ffuser.NewUser("user-key"), evaluationCtx: flag.EvaluationContext{ - DefaultSdkValue: testconvert.Interface("default-sdk"), + DefaultSdkValue: "default-sdk", }, }, - want: testconvert.Interface("default-sdk"), + want: "default-sdk", want1: flag.ResolutionDetails{ Variant: "SdkDefault", Reason: flag.ReasonDisabled, @@ -138,7 +137,7 @@ func TestInternalFlag_Value(t *testing.T) { DefaultSdkValue: false, }, }, - want: testconvert.Interface(false), + want: false, want1: flag.ResolutionDetails{ Variant: "variation_B", Reason: flag.ReasonTargetingMatch, @@ -174,10 +173,10 @@ func TestInternalFlag_Value(t *testing.T) { flagName: "my-flag", user: ffuser.NewUser("user-key"), evaluationCtx: flag.EvaluationContext{ - DefaultSdkValue: testconvert.Interface("value_default"), + DefaultSdkValue: "value_default", }, }, - want: testconvert.Interface("value_C"), + want: "value_C", want1: flag.ResolutionDetails{ Variant: "variation_C", Reason: flag.ReasonTargetingMatch, @@ -211,10 +210,10 @@ func TestInternalFlag_Value(t *testing.T) { flagName: "my-flag", user: ffuser.NewUser("user-key"), evaluationCtx: flag.EvaluationContext{ - DefaultSdkValue: testconvert.Interface("value_default"), + DefaultSdkValue: "value_default", }, }, - want: testconvert.Interface("value_C"), + want: "value_C", want1: flag.ResolutionDetails{ Variant: "variation_C", Reason: flag.ReasonTargetingMatch, @@ -252,10 +251,10 @@ func TestInternalFlag_Value(t *testing.T) { flagName: "my-flag", user: ffuser.NewUserBuilder("user-key").AddCustom("company", "go-feature-flag").Build(), evaluationCtx: flag.EvaluationContext{ - DefaultSdkValue: testconvert.Interface("value_default"), + DefaultSdkValue: "value_default", }, }, - want: testconvert.Interface("value_D"), + want: "value_D", want1: flag.ResolutionDetails{ Variant: "variation_D", Reason: flag.ReasonTargetingMatch, @@ -288,10 +287,10 @@ func TestInternalFlag_Value(t *testing.T) { flagName: "my-flag", user: ffuser.NewUserBuilder("user-key").Build(), evaluationCtx: flag.EvaluationContext{ - DefaultSdkValue: testconvert.Interface("value_default"), + DefaultSdkValue: "value_default", }, }, - want: testconvert.Interface("value_default"), + want: "value_default", want1: flag.ResolutionDetails{ Variant: flag.VariationSDKDefault, Reason: flag.ReasonError, @@ -321,10 +320,10 @@ func TestInternalFlag_Value(t *testing.T) { flagName: "my-flag", user: ffuser.NewUserBuilder("user-key").Build(), evaluationCtx: flag.EvaluationContext{ - DefaultSdkValue: testconvert.Interface("value_default"), + DefaultSdkValue: "value_default", }, }, - want: testconvert.Interface("value_default"), + want: "value_default", want1: flag.ResolutionDetails{ Variant: flag.VariationSDKDefault, Reason: flag.ReasonError, @@ -351,10 +350,10 @@ func TestInternalFlag_Value(t *testing.T) { flagName: "my-flag", user: ffuser.NewUserBuilder("user-key").Build(), evaluationCtx: flag.EvaluationContext{ - DefaultSdkValue: testconvert.Interface("value_default"), + DefaultSdkValue: "value_default", }, }, - want: testconvert.Interface("value_default"), + want: "value_default", want1: flag.ResolutionDetails{ Variant: flag.VariationSDKDefault, Reason: flag.ReasonError, @@ -396,10 +395,10 @@ func TestInternalFlag_Value(t *testing.T) { flagName: "my-flag", user: ffuser.NewUserBuilder("user-key").Build(), evaluationCtx: flag.EvaluationContext{ - DefaultSdkValue: testconvert.Interface("value_default"), + DefaultSdkValue: "value_default", }, }, - want: testconvert.Interface("value_A"), + want: "value_A", want1: flag.ResolutionDetails{ Variant: "variation_A", Reason: flag.ReasonDefault, @@ -440,10 +439,10 @@ func TestInternalFlag_Value(t *testing.T) { flagName: "my-flag", user: ffuser.NewUserBuilder("user-key").Build(), evaluationCtx: flag.EvaluationContext{ - DefaultSdkValue: testconvert.Interface("value_default"), + DefaultSdkValue: "value_default", }, }, - want: testconvert.Interface("value_B"), + want: "value_B", want1: flag.ResolutionDetails{ Variant: "variation_B", Reason: flag.ReasonDefault, @@ -484,10 +483,10 @@ func TestInternalFlag_Value(t *testing.T) { flagName: "my-flag", user: ffuser.NewUserBuilder("user-key").Build(), evaluationCtx: flag.EvaluationContext{ - DefaultSdkValue: testconvert.Interface("value_default"), + DefaultSdkValue: "value_default", }, }, - want: testconvert.Interface("value_QWERTY"), + want: "value_QWERTY", want1: flag.ResolutionDetails{ Variant: "variation_B", Reason: flag.ReasonDefault, @@ -519,10 +518,10 @@ func TestInternalFlag_Value(t *testing.T) { flagName: "my-flag", user: ffuser.NewUserBuilder("user-key").Build(), evaluationCtx: flag.EvaluationContext{ - DefaultSdkValue: testconvert.Interface("value_default"), + DefaultSdkValue: "value_default", }, }, - want: testconvert.Interface("value_A"), + want: "value_A", want1: flag.ResolutionDetails{ Variant: "variation_A", Reason: flag.ReasonDefault, @@ -568,10 +567,10 @@ func TestInternalFlag_Value(t *testing.T) { flagName: "my-flag", user: ffuser.NewUserBuilder("user-key").Build(), evaluationCtx: flag.EvaluationContext{ - DefaultSdkValue: testconvert.Interface("value_default"), + DefaultSdkValue: "value_default", }, }, - want: testconvert.Interface("value_C"), + want: "value_C", want1: flag.ResolutionDetails{ Variant: "variation_C", Reason: flag.ReasonTargetingMatch, @@ -613,10 +612,10 @@ func TestInternalFlag_Value(t *testing.T) { flagName: "my-flag", user: ffuser.NewUserBuilder("user-key-123").Build(), evaluationCtx: flag.EvaluationContext{ - DefaultSdkValue: testconvert.Interface("value_default"), + DefaultSdkValue: "value_default", }, }, - want: testconvert.Interface("value_C"), + want: "value_C", want1: flag.ResolutionDetails{ Variant: "variation_C", Reason: flag.ReasonDefault, @@ -663,10 +662,10 @@ func TestInternalFlag_Value(t *testing.T) { flagName: "my-flag", user: ffuser.NewUserBuilder("user-key-123").Build(), evaluationCtx: flag.EvaluationContext{ - DefaultSdkValue: testconvert.Interface("value_default"), + DefaultSdkValue: "value_default", }, }, - want: testconvert.Interface("value_C"), + want: "value_C", want1: flag.ResolutionDetails{ Variant: "variation_C", Reason: flag.ReasonTargetingMatch, @@ -709,10 +708,10 @@ func TestInternalFlag_Value(t *testing.T) { flagName: "my-flag", user: ffuser.NewUserBuilder("user-key").Build(), evaluationCtx: flag.EvaluationContext{ - DefaultSdkValue: testconvert.Interface("value_default"), + DefaultSdkValue: "value_default", }, }, - want: testconvert.Interface("value_QWERTY"), + want: "value_QWERTY", want1: flag.ResolutionDetails{ Variant: "variation_B", Reason: flag.ReasonDefault, @@ -745,10 +744,10 @@ func TestInternalFlag_Value(t *testing.T) { flagName: "my-flag", user: ffuser.NewUserBuilder("user-key").Build(), evaluationCtx: flag.EvaluationContext{ - DefaultSdkValue: testconvert.Interface("value_default"), + DefaultSdkValue: "value_default", }, }, - want: testconvert.Interface("value_default"), + want: "value_default", want1: flag.ResolutionDetails{ Variant: flag.VariationSDKDefault, Reason: flag.ReasonDisabled, @@ -784,10 +783,10 @@ func TestInternalFlag_Value(t *testing.T) { flagName: "my-flag", user: ffuser.NewUserBuilder("user-key").Build(), evaluationCtx: flag.EvaluationContext{ - DefaultSdkValue: testconvert.Interface("value_default"), + DefaultSdkValue: "value_default", }, }, - want: testconvert.Interface("value_A"), + want: "value_A", want1: flag.ResolutionDetails{ Variant: "variation_A", Reason: flag.ReasonDefault, @@ -797,7 +796,6 @@ func TestInternalFlag_Value(t *testing.T) { for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { got, got1 := tt.flag.Value(tt.args.flagName, tt.args.user, tt.args.evaluationCtx) - fmt.Println() assert.Equalf(t, tt.want, got, "not expected value: %s", cmp.Diff(tt.want, got)) assert.Equalf(t, tt.want1, got1, "not expected value: %s", cmp.Diff(tt.want1, got1)) }) diff --git a/internal/toremove/toremove.go b/internal/toremove/toremove.go new file mode 100644 index 00000000000..6b0c94be3ad --- /dev/null +++ b/internal/toremove/toremove.go @@ -0,0 +1,42 @@ +package main + +import ( + "fmt" + "github.com/thomaspoignant/go-feature-flag/internal/dto" + "github.com/thomaspoignant/go-feature-flag/testutils/testconvert" + "gopkg.in/yaml.v2" +) + +func main() { + t := map[string]dto.DTO{ + "test-flag": { + DTOv0: dto.DTOv0{ + Disable: nil, + Rule: testconvert.String("key eq \"random-key\""), + Percentage: testconvert.Float64(100), + True: testconvert.Interface(true), + False: testconvert.Interface(false), + Default: testconvert.Interface(false), + TrackEvents: testconvert.Bool(false), + }, + }, + "test-flag2": { + DTOv0: dto.DTOv0{ + Disable: nil, + Rule: testconvert.String("key eq \"random-key\""), + Percentage: testconvert.Float64(0), + True: testconvert.Interface("true"), + False: testconvert.Interface("false"), + Default: testconvert.Interface("false"), + TrackEvents: testconvert.Bool(false), + }, + }, + } + + for k, v := range t { + fmt.Println("--- " + k) + y, _ := yaml.Marshal(v.Convert()) + fmt.Println(string(y)) + + } +} diff --git a/testdata/ffclient/all_flags/marshal_json/error_in_flag_0.json b/testdata/ffclient/all_flags/marshal_json/error_in_flag_0.json index 8794eda5ee5..b25fa03b9b1 100644 --- a/testdata/ffclient/all_flags/marshal_json/error_in_flag_0.json +++ b/testdata/ffclient/all_flags/marshal_json/error_in_flag_0.json @@ -13,7 +13,7 @@ "timestamp": 1622206239, "variationType": "True", "trackEvents": true, - "reason":"TARGETING_MATCH", + "reason":"DEFAULT", "errorCode": "" }, "test-flag2": { @@ -21,7 +21,7 @@ "timestamp": 1622206239, "variationType": "True", "trackEvents": true, - "reason":"TARGETING_MATCH", + "reason":"DEFAULT", "errorCode": "" }, "test-flag3": { @@ -32,7 +32,7 @@ "timestamp": 1622206239, "variationType": "True", "trackEvents": true, - "reason":"TARGETING_MATCH", + "reason":"DEFAULT", "errorCode": "" }, "test-flag4": { @@ -42,7 +42,7 @@ "timestamp": 1622206239, "variationType": "True", "trackEvents": true, - "reason":"TARGETING_MATCH", + "reason":"DEFAULT", "errorCode": "" }, "test-flag5": { @@ -50,7 +50,7 @@ "timestamp": 1622206239, "variationType": "True", "trackEvents": false, - "reason":"TARGETING_MATCH", + "reason":"DEFAULT", "errorCode": "" } }, diff --git a/testdata/ffclient/all_flags/marshal_json/valid_multiple_types.json b/testdata/ffclient/all_flags/marshal_json/valid_multiple_types.json index 93e7c746cea..99e84f8a127 100644 --- a/testdata/ffclient/all_flags/marshal_json/valid_multiple_types.json +++ b/testdata/ffclient/all_flags/marshal_json/valid_multiple_types.json @@ -5,7 +5,7 @@ "timestamp": 1622206239, "variationType": "True", "trackEvents": true, - "reason":"TARGETING_MATCH", + "reason":"DEFAULT", "errorCode": "" }, "test-flag1": { @@ -13,7 +13,7 @@ "timestamp": 1622206239, "variationType": "True", "trackEvents": true, - "reason":"TARGETING_MATCH", + "reason":"DEFAULT", "errorCode": "" }, "test-flag2": { @@ -21,7 +21,7 @@ "timestamp": 1622206239, "variationType": "True", "trackEvents": true, - "reason":"TARGETING_MATCH", + "reason":"DEFAULT", "errorCode": "" }, "test-flag3": { @@ -32,7 +32,7 @@ "timestamp": 1622206239, "variationType": "True", "trackEvents": true, - "reason":"TARGETING_MATCH", + "reason":"DEFAULT", "errorCode": "" }, "test-flag4": { @@ -42,7 +42,7 @@ "timestamp": 1622206239, "variationType": "True", "trackEvents": true, - "reason":"TARGETING_MATCH", + "reason":"DEFAULT", "errorCode": "" }, "test-flag5": { @@ -50,7 +50,7 @@ "timestamp": 1622206239, "variationType": "True", "trackEvents": false, - "reason":"TARGETING_MATCH", + "reason":"DEFAULT", "errorCode": "" }, "test-flag6": { diff --git a/variation.go b/variation.go index 243b7d77725..f99bd104fad 100644 --- a/variation.go +++ b/variation.go @@ -211,7 +211,7 @@ func (g *GoFeatureFlag) GetFlagsFromCache() (map[string]flag.Flag, error) { } // boolVariation is the internal func that handle the logic of a variation with a bool value -// the result will always contains a valid model.BoolVarResult +// the result will always contain a valid model.BoolVarResult func (g *GoFeatureFlag) boolVariation(flagKey string, user ffuser.User, sdkDefaultValue bool, ) (model.BoolVarResult, error) { if g.config.Offline { From 84f729fb4e19025443a676ef44aafe9f919d165c Mon Sep 17 00:00:00 2001 From: Thomas Poignant Date: Fri, 29 Jul 2022 16:59:08 +0200 Subject: [PATCH 04/50] Remove nil field Signed-off-by: Thomas Poignant --- internal/cache/cache_manager_test.go | 9 ++------- internal/dto/converter_v0.go | 16 ++++++++++------ internal/dto/dto.go | 5 +++-- internal/flag/internal_flag.go | 2 +- internal/toremove/toremove.go | 2 +- 5 files changed, 17 insertions(+), 17 deletions(-) diff --git a/internal/cache/cache_manager_test.go b/internal/cache/cache_manager_test.go index a5aafb7b6f1..237e81526ae 100644 --- a/internal/cache/cache_manager_test.go +++ b/internal/cache/cache_manager_test.go @@ -1,11 +1,12 @@ package cache_test import ( - "github.com/thomaspoignant/go-feature-flag/internal/flag" "log" "os" "testing" + "github.com/thomaspoignant/go-feature-flag/internal/flag" + "github.com/stretchr/testify/assert" "github.com/thomaspoignant/go-feature-flag/internal/cache" "github.com/thomaspoignant/go-feature-flag/notifier" @@ -80,7 +81,6 @@ func Test_FlagCache(t *testing.T) { "False": 0, "True": 100, }, - ProgressiveRollout: nil, }, }, Variations: &map[string]*interface{}{ @@ -127,7 +127,6 @@ func Test_FlagCache(t *testing.T) { "False": 0, "True": 100, }, - ProgressiveRollout: nil, }, }, Variations: &map[string]*interface{}{ @@ -176,7 +175,6 @@ func Test_FlagCache(t *testing.T) { "False": 0, "True": 100, }, - ProgressiveRollout: nil, }, }, Variations: &map[string]*interface{}{ @@ -268,7 +266,6 @@ func Test_AllFlags(t *testing.T) { "False": 0, "True": 100, }, - ProgressiveRollout: nil, }, }, DefaultRule: &flag.Rule{ @@ -315,7 +312,6 @@ test-flag2: "False": 0, "True": 100, }, - ProgressiveRollout: nil, }, }, DefaultRule: &flag.Rule{ @@ -338,7 +334,6 @@ test-flag2: "False": 100, "True": 0, }, - ProgressiveRollout: nil, }, }, DefaultRule: &flag.Rule{ diff --git a/internal/dto/converter_v0.go b/internal/dto/converter_v0.go index 4964d8004ad..e51fb27a13e 100644 --- a/internal/dto/converter_v0.go +++ b/internal/dto/converter_v0.go @@ -2,12 +2,16 @@ package dto import "github.com/thomaspoignant/go-feature-flag/internal/flag" -var LegacyRuleName = "legacyRuleV0" -var defaultRuleName = "legacyDefaultRule" +var ( + LegacyRuleName = "legacyRuleV0" + defaultRuleName = "legacyDefaultRule" +) -var trueVariation = "True" -var falseVariation = "False" -var defaultVariation = "Default" +var ( + trueVariation = "True" + falseVariation = "False" + defaultVariation = "Default" +) // ConvertV0DtoToFlag is converting a flag in the config file to the internal format. // this function convert only the old format of the flag (before v1.0.0), to keep @@ -96,7 +100,7 @@ func createLegacyRuleV0(d DTO, isScheduleStep bool) flag.Rule { // createVariationsV0 will create a set of variations based on the previous format func createVariationsV0(d DTO, isScheduleStep bool) map[string]*interface{} { - var variations = make(map[string]*interface{}, 3) + variations := make(map[string]*interface{}, 3) if d.True != nil { variations[trueVariation] = d.True } diff --git a/internal/dto/dto.go b/internal/dto/dto.go index 6a935ee145c..55771499f32 100644 --- a/internal/dto/dto.go +++ b/internal/dto/dto.go @@ -1,9 +1,10 @@ package dto import ( + "strconv" + "github.com/thomaspoignant/go-feature-flag/internal/flag" "github.com/thomaspoignant/go-feature-flag/internal/flagv1" - "strconv" ) // DTO is representing all the fields we can have in a flag. @@ -71,7 +72,7 @@ func (d *DTO) ConvertLegacy() flagv1.FlagData { func (d *DTO) Convert() flag.InternalFlag { return ConvertV0DtoToFlag(*d, false) - //return flagv1.FlagData{ + // return flagv1.FlagData{ // Rule: d.Rule, // Percentage: d.Percentage, // True: d.True, diff --git a/internal/flag/internal_flag.go b/internal/flag/internal_flag.go index 4c7f9950057..c0f504d422d 100644 --- a/internal/flag/internal_flag.go +++ b/internal/flag/internal_flag.go @@ -47,7 +47,7 @@ type InternalFlag struct { } func (f *InternalFlag) String() string { - //TODO implement me + panic("implement me") } diff --git a/internal/toremove/toremove.go b/internal/toremove/toremove.go index 6b0c94be3ad..8d261f9ba7b 100644 --- a/internal/toremove/toremove.go +++ b/internal/toremove/toremove.go @@ -2,6 +2,7 @@ package main import ( "fmt" + "github.com/thomaspoignant/go-feature-flag/internal/dto" "github.com/thomaspoignant/go-feature-flag/testutils/testconvert" "gopkg.in/yaml.v2" @@ -37,6 +38,5 @@ func main() { fmt.Println("--- " + k) y, _ := yaml.Marshal(v.Convert()) fmt.Println(string(y)) - } } From 16e031201256d2128d61ba1de5dcb2ee5d6c2c84 Mon Sep 17 00:00:00 2001 From: Thomas Poignant Date: Fri, 29 Jul 2022 17:03:16 +0200 Subject: [PATCH 05/50] Remove unused test files Signed-off-by: Thomas Poignant --- internal/flag/rollout_experimentation_test.go | 52 ------------ internal/flag/rollout_scheduled_test.go | 85 ------------------- 2 files changed, 137 deletions(-) delete mode 100644 internal/flag/rollout_experimentation_test.go delete mode 100644 internal/flag/rollout_scheduled_test.go diff --git a/internal/flag/rollout_experimentation_test.go b/internal/flag/rollout_experimentation_test.go deleted file mode 100644 index 0c48db7cf3e..00000000000 --- a/internal/flag/rollout_experimentation_test.go +++ /dev/null @@ -1,52 +0,0 @@ -package flag_test - -import ( - "testing" -) - -func TestExperimentation_String(t *testing.T) { - // type fields struct { - // StartDate *time.Time - // EndDate *time.Time - // Start *time.Time - // End *time.Time - //} - // tests := []struct { - // name string - // fields fields - // want string - // }{ - // { - // name: "both dates", - // fields: fields{ - // Start: testconvert.Time(time.Unix(1095379400, 0)), - // End: testconvert.Time(time.Unix(1095379500, 0)), - // }, - // want: "start:[2004-09-17T00:03:20Z] end:[2004-09-17T00:05:00Z]", - // }, - // { - // name: "only start date", - // fields: fields{ - // Start: testconvert.Time(time.Unix(1095379400, 0)), - // }, - // want: "start:[2004-09-17T00:03:20Z]", - // }, - // { - // name: "only end date", - // fields: fields{ - // End: testconvert.Time(time.Unix(1095379500, 0)), - // }, - // want: "end:[2004-09-17T00:05:00Z]", - // }, - //} - // for _, tt := range tests { - // t.Run(tt.name, func(t *testing.T) { - // e := flag.ExperimentationRollout{ - // End: tt.fields.End, - // Start: tt.fields.Start, - // } - // got := e.String() - // assert.Equal(t, tt.want, got) - // }) - //} -} diff --git a/internal/flag/rollout_scheduled_test.go b/internal/flag/rollout_scheduled_test.go deleted file mode 100644 index 978b03293cb..00000000000 --- a/internal/flag/rollout_scheduled_test.go +++ /dev/null @@ -1,85 +0,0 @@ -package flag_test - -// func TestScheduledRollout_String(t *testing.T) { -// type fields struct { -// Steps []flag.ScheduledStep -// } -// tests := []struct { -// name string -// fields fields -// want string -// }{ -// { -// name: "Simple 2 steps", -// want: "[2021-02-01T10:10:10Z: Version:[1.10]],[2021-02-02T10:10:10Z: Variations:[A=yo,B=y1]]", -// fields: fields{Steps: []flag.ScheduledStep{ -// { -// InternalFlag: flag.InternalFlag{ -// Version: testconvert.String(fmt.Sprintf("%.2f", 1.1)), -// }, -// Date: testconvert.Time(time.Date(2021, time.February, 1, 10, 10, 10, 10, time.UTC)), -// }, -// { -// InternalFlag: flag.InternalFlag{ -// Variations: &map[string]*interface{}{ -// "A": testconvert.Interface("yo"), -// "B": testconvert.Interface("y1"), -// }, -// }, -// Date: testconvert.Time(time.Date(2021, time.February, 2, 10, 10, 10, 10, time.UTC)), -// }, -// }}, -// }, -// { -// name: "Complex steps", -// want: "[2021-02-01T10:10:10Z: Version:[1.10]],[2021-02-02T10:10:10Z: Variations:[A=yo,B=y1], " + -// "DefaultRule:[query:[key eq \"toto\"], percentages:" + -// "[A=10.00,B=90.00], progressiveRollout:[Initial:[Variation:[A], Percentage:[10], Date:[2021-02-01T10:10:10Z]]," + -// " End:[Variation:[B], Percentage:[90], Date:[2021-02-04T10:10:10Z]]]]]", -// fields: fields{Steps: []flag.ScheduledStep{ -// { -// InternalFlag: flag.InternalFlag{ -// Version: testconvert.String(fmt.Sprintf("%.2f", 1.1)), -// }, -// Date: testconvert.Time(time.Date(2021, time.February, 1, 10, 10, 10, 10, time.UTC)), -// }, -// { -// InternalFlag: flag.InternalFlag{ -// Variations: &map[string]*interface{}{ -// "A": testconvert.Interface("yo"), -// "B": testconvert.Interface("y1"), -// }, -// DefaultRule: &flag.Rule{ -// Query: testconvert.String("key eq \"toto\""), -// Percentages: &map[string]float64{ -// "A": 10, -// "B": 90, -// }, -// ProgressiveRollout: &flag.ProgressiveRollout{ -// Initial: &flag.ProgressiveRolloutStep{ -// Variation: testconvert.String("A"), -// Percentage: 10, -// Date: testconvert.Time(time.Date(2021, time.February, 1, 10, 10, 10, 10, time.UTC)), -// }, -// End: &flag.ProgressiveRolloutStep{ -// Variation: testconvert.String("B"), -// Percentage: 90, -// Date: testconvert.Time(time.Date(2021, time.February, 4, 10, 10, 10, 10, time.UTC)), -// }, -// }, -// }, -// }, -// Date: testconvert.Time(time.Date(2021, time.February, 2, 10, 10, 10, 10, time.UTC)), -// }, -// }}, -// }, -// } -// for _, tt := range tests { -// t.Run(tt.name, func(t *testing.T) { -// s := flag.ScheduledRollout{ -// Steps: tt.fields.Steps, -// } -// assert.Equalf(t, tt.want, s.String(), "String()") -// }) -// } -//} From 0679472c52eba9fc491574f8a9cd12179559b398 Mon Sep 17 00:00:00 2001 From: Thomas Poignant Date: Fri, 29 Jul 2022 17:07:29 +0200 Subject: [PATCH 06/50] Unused util function Signed-off-by: Thomas Poignant --- internal/utils/stringAppender.go | 12 ------------ 1 file changed, 12 deletions(-) delete mode 100644 internal/utils/stringAppender.go diff --git a/internal/utils/stringAppender.go b/internal/utils/stringAppender.go deleted file mode 100644 index 83f15af9472..00000000000 --- a/internal/utils/stringAppender.go +++ /dev/null @@ -1,12 +0,0 @@ -package utils - -import ( - "fmt" -) - -func AppendIfHasValue(toString []string, key string, value string) []string { - if value != "" { - toString = append(toString, fmt.Sprintf("%s:[%v]", key, value)) - } - return toString -} From 9118f832efd665f3ebcda475894069b43c1fdf9d Mon Sep 17 00:00:00 2001 From: Thomas Poignant Date: Fri, 29 Jul 2022 17:09:38 +0200 Subject: [PATCH 07/50] Remove println Signed-off-by: Thomas Poignant --- notifier/slacknotifier/notifier_test.go | 2 -- 1 file changed, 2 deletions(-) diff --git a/notifier/slacknotifier/notifier_test.go b/notifier/slacknotifier/notifier_test.go index 405bad94900..d50f7638805 100644 --- a/notifier/slacknotifier/notifier_test.go +++ b/notifier/slacknotifier/notifier_test.go @@ -1,7 +1,6 @@ package slacknotifier import ( - "fmt" "io/ioutil" "net/http" "os" @@ -167,7 +166,6 @@ func TestSlackNotifier_Notify(t *testing.T) { hostname, _ := os.Hostname() content, _ := ioutil.ReadFile(tt.expected.bodyPath) expectedContent := strings.ReplaceAll(string(content), "{{hostname}}", hostname) - fmt.Println(mockHTTPClient.Body) assert.JSONEq(t, expectedContent, mockHTTPClient.Body) assert.Equal(t, tt.expected.signature, mockHTTPClient.Signature) } From a229b13dc70736870273f232e9b8fd5d333b05fe Mon Sep 17 00:00:00 2001 From: Thomas Poignant Date: Fri, 29 Jul 2022 18:07:36 +0200 Subject: [PATCH 08/50] Remove flag_data from variation test Signed-off-by: Thomas Poignant --- internal/flag/internal_flag.go | 1 - internal/toremove/toremove.go | 12 - variation_test.go | 900 ++++++++++++++++++++++++--------- 3 files changed, 659 insertions(+), 254 deletions(-) diff --git a/internal/flag/internal_flag.go b/internal/flag/internal_flag.go index c0f504d422d..d513e46cea9 100644 --- a/internal/flag/internal_flag.go +++ b/internal/flag/internal_flag.go @@ -47,7 +47,6 @@ type InternalFlag struct { } func (f *InternalFlag) String() string { - panic("implement me") } diff --git a/internal/toremove/toremove.go b/internal/toremove/toremove.go index 8d261f9ba7b..66494bc7b4c 100644 --- a/internal/toremove/toremove.go +++ b/internal/toremove/toremove.go @@ -12,7 +12,6 @@ func main() { t := map[string]dto.DTO{ "test-flag": { DTOv0: dto.DTOv0{ - Disable: nil, Rule: testconvert.String("key eq \"random-key\""), Percentage: testconvert.Float64(100), True: testconvert.Interface(true), @@ -21,17 +20,6 @@ func main() { TrackEvents: testconvert.Bool(false), }, }, - "test-flag2": { - DTOv0: dto.DTOv0{ - Disable: nil, - Rule: testconvert.String("key eq \"random-key\""), - Percentage: testconvert.Float64(0), - True: testconvert.Interface("true"), - False: testconvert.Interface("false"), - Default: testconvert.Interface("false"), - TrackEvents: testconvert.Bool(false), - }, - }, } for k, v := range t { diff --git a/variation_test.go b/variation_test.go index 4787907919b..596d70f20a7 100644 --- a/variation_test.go +++ b/variation_test.go @@ -4,6 +4,7 @@ import ( "context" "encoding/json" "errors" + "github.com/thomaspoignant/go-feature-flag/internal/model" "io/ioutil" "log" "os" @@ -18,12 +19,9 @@ import ( "github.com/thomaspoignant/go-feature-flag/retriever/fileretriever" "github.com/stretchr/testify/assert" - "github.com/thomaspoignant/go-feature-flag/internal/flag" - flagv1 "github.com/thomaspoignant/go-feature-flag/internal/flagv1" - "github.com/thomaspoignant/go-feature-flag/internal/model" - "github.com/thomaspoignant/go-feature-flag/ffuser" "github.com/thomaspoignant/go-feature-flag/internal/cache" + "github.com/thomaspoignant/go-feature-flag/internal/flag" "github.com/thomaspoignant/go-feature-flag/testutils" "github.com/thomaspoignant/go-feature-flag/testutils/testconvert" ) @@ -74,7 +72,7 @@ func TestBoolVariation(t *testing.T) { flagKey: "disable-flag", user: ffuser.NewUser("random-key"), defaultValue: true, - cacheMock: NewCacheMock(&flagv1.FlagData{ + cacheMock: NewCacheMock(&flag.InternalFlag{ Disable: testconvert.Bool(true), }, nil), }, @@ -89,7 +87,7 @@ func TestBoolVariation(t *testing.T) { user: ffuser.NewUser("random-key"), defaultValue: true, cacheMock: NewCacheMock( - &flagv1.FlagData{}, + &flag.InternalFlag{}, errors.New("impossible to read the toggle before the initialisation")), }, want: true, @@ -102,7 +100,7 @@ func TestBoolVariation(t *testing.T) { flagKey: "key-not-exist", user: ffuser.NewUser("random-key"), defaultValue: true, - cacheMock: NewCacheMock(&flagv1.FlagData{}, errors.New("flag [key-not-exist] does not exists")), + cacheMock: NewCacheMock(&flag.InternalFlag{}, errors.New("flag [key-not-exist] does not exists")), }, want: true, wantErr: true, @@ -114,12 +112,26 @@ func TestBoolVariation(t *testing.T) { flagKey: "test-flag", user: ffuser.NewUser("random-key"), defaultValue: true, - cacheMock: NewCacheMock(&flagv1.FlagData{ - Rule: testconvert.String("key eq \"key\""), - Percentage: testconvert.Float64(100), - Default: testconvert.Interface(true), - True: testconvert.Interface(false), - False: testconvert.Interface(false), + cacheMock: NewCacheMock(&flag.InternalFlag{ + Rules: &[]flag.Rule{ + { + Name: testconvert.String("legacyRuleV0"), + Query: testconvert.String("key eq \"key\""), + Percentages: &map[string]float64{ + "False": 0, + "True": 100, + }, + }, + }, + Variations: &map[string]*interface{}{ + "Default": testconvert.Interface(true), + "False": testconvert.Interface(false), + "True": testconvert.Interface(true), + }, + DefaultRule: &flag.Rule{ + Name: testconvert.String("legacyDefaultRule"), + VariationResult: testconvert.String("Default"), + }, }, nil), }, want: true, @@ -132,12 +144,26 @@ func TestBoolVariation(t *testing.T) { flagKey: "test-flag", user: ffuser.NewAnonymousUser("random-key"), defaultValue: true, - cacheMock: NewCacheMock(&flagv1.FlagData{ - Rule: testconvert.String("key eq \"random-key\""), - Percentage: testconvert.Float64(100), - Default: testconvert.Interface(false), - True: testconvert.Interface(true), - False: testconvert.Interface(false), + cacheMock: NewCacheMock(&flag.InternalFlag{ + Rules: &[]flag.Rule{ + { + Name: testconvert.String("legacyRuleV0"), + Query: testconvert.String("key eq \"random-key\""), + Percentages: &map[string]float64{ + "False": 0, + "True": 100, + }, + }, + }, + Variations: &map[string]*interface{}{ + "Default": testconvert.Interface(false), + "False": testconvert.Interface(false), + "True": testconvert.Interface(true), + }, + DefaultRule: &flag.Rule{ + Name: testconvert.String("legacyDefaultRule"), + VariationResult: testconvert.String("Default"), + }, }, nil), }, want: true, @@ -150,12 +176,26 @@ func TestBoolVariation(t *testing.T) { flagKey: "test-flag", user: ffuser.NewAnonymousUser("random-key-ssss1"), defaultValue: true, - cacheMock: NewCacheMock(&flagv1.FlagData{ - Rule: testconvert.String("anonymous eq true"), - Percentage: testconvert.Float64(10), - Default: testconvert.Interface(true), - True: testconvert.Interface(true), - False: testconvert.Interface(false), + cacheMock: NewCacheMock(&flag.InternalFlag{ + Rules: &[]flag.Rule{ + { + Name: testconvert.String("legacyRuleV0"), + Query: testconvert.String("anonymous eq true"), + Percentages: &map[string]float64{ + "False": 90, + "True": 10, + }, + }, + }, + Variations: &map[string]*interface{}{ + "Default": testconvert.Interface(false), + "False": testconvert.Interface(false), + "True": testconvert.Interface(true), + }, + DefaultRule: &flag.Rule{ + Name: testconvert.String("legacyDefaultRule"), + VariationResult: testconvert.String("Default"), + }, }, nil), }, want: false, @@ -168,11 +208,26 @@ func TestBoolVariation(t *testing.T) { flagKey: "test-flag", user: ffuser.NewUser("random-key-ssss1"), defaultValue: true, - cacheMock: NewCacheMock(&flagv1.FlagData{ - Percentage: testconvert.Float64(100), - Default: testconvert.Interface("xxx"), - True: testconvert.Interface("xxx"), - False: testconvert.Interface("xxx"), + cacheMock: NewCacheMock(&flag.InternalFlag{ + Rules: &[]flag.Rule{ + { + Name: testconvert.String("legacyRuleV0"), + Query: testconvert.String("key eq \"random-key\""), + Percentages: &map[string]float64{ + "False": 0, + "True": 100, + }, + }, + }, + Variations: &map[string]*interface{}{ + "Default": testconvert.Interface("xxx"), + "False": testconvert.Interface("xxx"), + "True": testconvert.Interface("xxx"), + }, + DefaultRule: &flag.Rule{ + Name: testconvert.String("legacyDefaultRule"), + VariationResult: testconvert.String("Default"), + }, }, nil), }, want: true, @@ -185,12 +240,26 @@ func TestBoolVariation(t *testing.T) { flagKey: "test-flag", user: ffuser.NewAnonymousUser("random-key"), defaultValue: true, - cacheMock: NewCacheMock(&flagv1.FlagData{ - Rule: testconvert.String("key eq \"random-key\""), - Percentage: testconvert.Float64(100), - True: testconvert.Interface(true), - False: testconvert.Interface(false), - Default: testconvert.Interface(false), + cacheMock: NewCacheMock(&flag.InternalFlag{ + Rules: &[]flag.Rule{ + { + Name: testconvert.String("legacyRuleV0"), + Query: testconvert.String("key eq \"random-key\""), + Percentages: &map[string]float64{ + "False": 0, + "True": 100, + }, + }, + }, + Variations: &map[string]*interface{}{ + "Default": testconvert.Interface(false), + "False": testconvert.Interface(false), + "True": testconvert.Interface(true), + }, + DefaultRule: &flag.Rule{ + Name: testconvert.String("legacyDefaultRule"), + VariationResult: testconvert.String("Default"), + }, TrackEvents: testconvert.Bool(false), }, nil), }, @@ -205,7 +274,7 @@ func TestBoolVariation(t *testing.T) { flagKey: "disable-flag", user: ffuser.NewUser("random-key"), defaultValue: false, - cacheMock: NewCacheMock(&flagv1.FlagData{ + cacheMock: NewCacheMock(&flag.InternalFlag{ Disable: testconvert.Bool(true), }, nil), }, @@ -276,7 +345,7 @@ func TestFloat64Variation(t *testing.T) { flagKey: "disable-flag", user: ffuser.NewUser("random-key"), defaultValue: 120.12, - cacheMock: NewCacheMock(&flagv1.FlagData{ + cacheMock: NewCacheMock(&flag.InternalFlag{ Disable: testconvert.Bool(true), }, nil), }, @@ -291,7 +360,7 @@ func TestFloat64Variation(t *testing.T) { user: ffuser.NewUser("random-key"), defaultValue: 118.12, cacheMock: NewCacheMock( - &flagv1.FlagData{}, + &flag.InternalFlag{}, errors.New("impossible to read the toggle before the initialisation")), }, want: 118.12, @@ -304,7 +373,7 @@ func TestFloat64Variation(t *testing.T) { flagKey: "key-not-exist", user: ffuser.NewUser("random-key"), defaultValue: 118.12, - cacheMock: NewCacheMock(&flagv1.FlagData{}, errors.New("flag [key-not-exist] does not exists")), + cacheMock: NewCacheMock(&flag.InternalFlag{}, errors.New("flag [key-not-exist] does not exists")), }, want: 118.12, wantErr: true, @@ -316,12 +385,26 @@ func TestFloat64Variation(t *testing.T) { flagKey: "test-flag", user: ffuser.NewUser("random-key"), defaultValue: 118.12, - cacheMock: NewCacheMock(&flagv1.FlagData{ - Rule: testconvert.String("key eq \"key\""), - Percentage: testconvert.Float64(100), - Default: testconvert.Interface(119.12), - True: testconvert.Interface(120.12), - False: testconvert.Interface(121.12), + cacheMock: NewCacheMock(&flag.InternalFlag{ + Rules: &[]flag.Rule{ + { + Name: testconvert.String("legacyRuleV0"), + Query: testconvert.String("key eq \"key\""), + Percentages: &map[string]float64{ + "False": 0, + "True": 100, + }, + }, + }, + Variations: &map[string]*interface{}{ + "Default": testconvert.Interface(119.12), + "False": testconvert.Interface(121.12), + "True": testconvert.Interface(120.12), + }, + DefaultRule: &flag.Rule{ + Name: testconvert.String("legacyDefaultRule"), + VariationResult: testconvert.String("Default"), + }, }, nil), }, want: 119.12, @@ -334,12 +417,26 @@ func TestFloat64Variation(t *testing.T) { flagKey: "test-flag", user: ffuser.NewAnonymousUser("random-key"), defaultValue: 118.12, - cacheMock: NewCacheMock(&flagv1.FlagData{ - Rule: testconvert.String("key eq \"random-key\""), - Percentage: testconvert.Float64(100), - Default: testconvert.Interface(119.12), - True: testconvert.Interface(120.12), - False: testconvert.Interface(121.12), + cacheMock: NewCacheMock(&flag.InternalFlag{ + Rules: &[]flag.Rule{ + { + Name: testconvert.String("legacyRuleV0"), + Query: testconvert.String("key eq \"random-key\""), + Percentages: &map[string]float64{ + "False": 0, + "True": 100, + }, + }, + }, + Variations: &map[string]*interface{}{ + "Default": testconvert.Interface(119.12), + "False": testconvert.Interface(121.12), + "True": testconvert.Interface(120.12), + }, + DefaultRule: &flag.Rule{ + Name: testconvert.String("legacyDefaultRule"), + VariationResult: testconvert.String("Default"), + }, }, nil), }, want: 120.12, @@ -352,12 +449,26 @@ func TestFloat64Variation(t *testing.T) { flagKey: "test-flag", user: ffuser.NewAnonymousUser("random-key-ssss1"), defaultValue: 118.12, - cacheMock: NewCacheMock(&flagv1.FlagData{ - Rule: testconvert.String("anonymous eq true"), - Percentage: testconvert.Float64(10), - Default: testconvert.Interface(119.12), - True: testconvert.Interface(120.12), - False: testconvert.Interface(121.12), + cacheMock: NewCacheMock(&flag.InternalFlag{ + Rules: &[]flag.Rule{ + { + Name: testconvert.String("legacyRuleV0"), + Query: testconvert.String("anonymous eq true"), + Percentages: &map[string]float64{ + "False": 90, + "True": 10, + }, + }, + }, + Variations: &map[string]*interface{}{ + "Default": testconvert.Interface(119.12), + "False": testconvert.Interface(121.12), + "True": testconvert.Interface(120.12), + }, + DefaultRule: &flag.Rule{ + Name: testconvert.String("legacyDefaultRule"), + VariationResult: testconvert.String("Default"), + }, }, nil), }, want: 121.12, @@ -370,11 +481,26 @@ func TestFloat64Variation(t *testing.T) { flagKey: "test-flag", user: ffuser.NewUser("random-key-ssss1"), defaultValue: 118.12, - cacheMock: NewCacheMock(&flagv1.FlagData{ - Percentage: testconvert.Float64(100), - Default: testconvert.Interface("xxx"), - True: testconvert.Interface("xxx"), - False: testconvert.Interface("xxx"), + cacheMock: NewCacheMock(&flag.InternalFlag{ + Rules: &[]flag.Rule{ + { + Name: testconvert.String("legacyRuleV0"), + Query: testconvert.String("key eq \"random-key\""), + Percentages: &map[string]float64{ + "False": 0, + "True": 100, + }, + }, + }, + Variations: &map[string]*interface{}{ + "Default": testconvert.Interface("xxx"), + "False": testconvert.Interface("xxx"), + "True": testconvert.Interface("xxx"), + }, + DefaultRule: &flag.Rule{ + Name: testconvert.String("legacyDefaultRule"), + VariationResult: testconvert.String("Default"), + }, }, nil), }, want: 118.12, @@ -387,12 +513,26 @@ func TestFloat64Variation(t *testing.T) { flagKey: "test-flag", user: ffuser.NewAnonymousUser("random-key"), defaultValue: 118.12, - cacheMock: NewCacheMock(&flagv1.FlagData{ - Rule: testconvert.String("key eq \"random-key\""), - Percentage: testconvert.Float64(100), - Default: testconvert.Interface(119.12), - True: testconvert.Interface(120.12), - False: testconvert.Interface(121.12), + cacheMock: NewCacheMock(&flag.InternalFlag{ + Rules: &[]flag.Rule{ + { + Name: testconvert.String("legacyRuleV0"), + Query: testconvert.String("key eq \"random-key\""), + Percentages: &map[string]float64{ + "False": 0, + "True": 100, + }, + }, + }, + Variations: &map[string]*interface{}{ + "Default": testconvert.Interface(119.12), + "False": testconvert.Interface(121.12), + "True": testconvert.Interface(120.12), + }, + DefaultRule: &flag.Rule{ + Name: testconvert.String("legacyDefaultRule"), + VariationResult: testconvert.String("Default"), + }, TrackEvents: testconvert.Bool(false), }, nil), }, @@ -407,7 +547,7 @@ func TestFloat64Variation(t *testing.T) { flagKey: "disable-flag", user: ffuser.NewUser("random-key"), defaultValue: 118.12, - cacheMock: NewCacheMock(&flagv1.FlagData{ + cacheMock: NewCacheMock(&flag.InternalFlag{ Disable: testconvert.Bool(true), }, nil), }, @@ -477,7 +617,7 @@ func TestJSONArrayVariation(t *testing.T) { flagKey: "disable-flag", user: ffuser.NewUser("random-key"), defaultValue: []interface{}{"toto"}, - cacheMock: NewCacheMock(&flagv1.FlagData{ + cacheMock: NewCacheMock(&flag.InternalFlag{ Disable: testconvert.Bool(true), }, nil), }, @@ -492,7 +632,7 @@ func TestJSONArrayVariation(t *testing.T) { user: ffuser.NewUser("random-key"), defaultValue: []interface{}{"toto"}, cacheMock: NewCacheMock( - &flagv1.FlagData{}, + &flag.InternalFlag{}, errors.New("impossible to read the toggle before the initialisation")), }, want: []interface{}{"toto"}, @@ -505,7 +645,7 @@ func TestJSONArrayVariation(t *testing.T) { flagKey: "key-not-exist", user: ffuser.NewUser("random-key"), defaultValue: []interface{}{"toto"}, - cacheMock: NewCacheMock(&flagv1.FlagData{}, errors.New("flag [key-not-exist] does not exists")), + cacheMock: NewCacheMock(&flag.InternalFlag{}, errors.New("flag [key-not-exist] does not exists")), }, want: []interface{}{"toto"}, wantErr: true, @@ -517,12 +657,26 @@ func TestJSONArrayVariation(t *testing.T) { flagKey: "test-flag", user: ffuser.NewUser("random-key"), defaultValue: []interface{}{"toto"}, - cacheMock: NewCacheMock(&flagv1.FlagData{ - Rule: testconvert.String("key eq \"key\""), - Percentage: testconvert.Float64(100), - Default: testconvert.Interface([]interface{}{"default"}), - True: testconvert.Interface([]interface{}{"true"}), - False: testconvert.Interface([]interface{}{"false"}), + cacheMock: NewCacheMock(&flag.InternalFlag{ + Rules: &[]flag.Rule{ + { + Name: testconvert.String("legacyRuleV0"), + Query: testconvert.String("key eq \"key\""), + Percentages: &map[string]float64{ + "False": 0, + "True": 100, + }, + }, + }, + Variations: &map[string]*interface{}{ + "Default": testconvert.Interface([]interface{}{"default"}), + "True": testconvert.Interface([]interface{}{"true"}), + "False": testconvert.Interface([]interface{}{"false"}), + }, + DefaultRule: &flag.Rule{ + Name: testconvert.String("legacyDefaultRule"), + VariationResult: testconvert.String("Default"), + }, }, nil), }, want: []interface{}{"default"}, @@ -535,12 +689,26 @@ func TestJSONArrayVariation(t *testing.T) { flagKey: "test-flag", user: ffuser.NewAnonymousUser("random-key"), defaultValue: []interface{}{"toto"}, - cacheMock: NewCacheMock(&flagv1.FlagData{ - Rule: testconvert.String("key eq \"random-key\""), - Percentage: testconvert.Float64(100), - Default: testconvert.Interface([]interface{}{"default"}), - True: testconvert.Interface([]interface{}{"true"}), - False: testconvert.Interface([]interface{}{"false"}), + cacheMock: NewCacheMock(&flag.InternalFlag{ + Rules: &[]flag.Rule{ + { + Name: testconvert.String("legacyRuleV0"), + Query: testconvert.String("key eq \"random-key\""), + Percentages: &map[string]float64{ + "False": 0, + "True": 100, + }, + }, + }, + Variations: &map[string]*interface{}{ + "Default": testconvert.Interface([]interface{}{"default"}), + "True": testconvert.Interface([]interface{}{"true"}), + "False": testconvert.Interface([]interface{}{"false"}), + }, + DefaultRule: &flag.Rule{ + Name: testconvert.String("legacyDefaultRule"), + VariationResult: testconvert.String("Default"), + }, }, nil), }, want: []interface{}{"true"}, @@ -553,12 +721,19 @@ func TestJSONArrayVariation(t *testing.T) { flagKey: "test-flag", user: ffuser.NewAnonymousUser("random-key-ssss1"), defaultValue: []interface{}{"toto"}, - cacheMock: NewCacheMock(&flagv1.FlagData{ - Rule: testconvert.String("anonymous eq true"), - Percentage: testconvert.Float64(10), - Default: testconvert.Interface([]interface{}{"default"}), - True: testconvert.Interface([]interface{}{"true"}), - False: testconvert.Interface([]interface{}{"false"}), + cacheMock: NewCacheMock(&flag.InternalFlag{ + Variations: &map[string]*interface{}{ + "Default": testconvert.Interface([]interface{}{"default"}), + "True": testconvert.Interface([]interface{}{"true"}), + "False": testconvert.Interface([]interface{}{"false"}), + }, + DefaultRule: &flag.Rule{ + Name: testconvert.String("legacyDefaultRule"), + Percentages: &map[string]float64{ + "False": 90, + "True": 10, + }, + }, }, nil), }, want: []interface{}{"false"}, @@ -571,11 +746,26 @@ func TestJSONArrayVariation(t *testing.T) { flagKey: "test-flag", user: ffuser.NewUser("random-key-ssss1"), defaultValue: []interface{}{"toto"}, - cacheMock: NewCacheMock(&flagv1.FlagData{ - Percentage: testconvert.Float64(100), - Default: testconvert.Interface("xxx"), - True: testconvert.Interface("xxx"), - False: testconvert.Interface("xxx"), + cacheMock: NewCacheMock(&flag.InternalFlag{ + Rules: &[]flag.Rule{ + { + Name: testconvert.String("legacyRuleV0"), + Query: testconvert.String("key eq \"key\""), + Percentages: &map[string]float64{ + "False": 0, + "True": 100, + }, + }, + }, + Variations: &map[string]*interface{}{ + "Default": testconvert.Interface("xxx"), + "False": testconvert.Interface("xxx"), + "True": testconvert.Interface("xxx"), + }, + DefaultRule: &flag.Rule{ + Name: testconvert.String("legacyDefaultRule"), + VariationResult: testconvert.String("Default"), + }, }, nil), }, want: []interface{}{"toto"}, @@ -588,11 +778,19 @@ func TestJSONArrayVariation(t *testing.T) { flagKey: "test-flag", user: ffuser.NewUser("random-key-ssss1"), defaultValue: []interface{}{"toto"}, - cacheMock: NewCacheMock(&flagv1.FlagData{ - Percentage: testconvert.Float64(100), - Default: testconvert.Interface([]interface{}{"default"}), - True: testconvert.Interface([]interface{}{"true"}), - False: testconvert.Interface([]interface{}{"false"}), + cacheMock: NewCacheMock(&flag.InternalFlag{ + Variations: &map[string]*interface{}{ + "Default": testconvert.Interface([]interface{}{"default"}), + "True": testconvert.Interface([]interface{}{"true"}), + "False": testconvert.Interface([]interface{}{"false"}), + }, + DefaultRule: &flag.Rule{ + Name: testconvert.String("legacyDefaultRule"), + Percentages: &map[string]float64{ + "False": 0, + "True": 100, + }, + }, TrackEvents: testconvert.Bool(false), }, nil), }, @@ -600,25 +798,6 @@ func TestJSONArrayVariation(t *testing.T) { wantErr: false, expectedLog: "^$", }, - { - name: "No exported data", - args: args{ - flagKey: "test-flag", - user: ffuser.NewAnonymousUser("random-key-ssss1"), - defaultValue: []interface{}{"toto"}, - cacheMock: NewCacheMock(&flagv1.FlagData{ - Rule: testconvert.String("anonymous eq true"), - Percentage: testconvert.Float64(10), - Default: testconvert.Interface([]interface{}{"default"}), - True: testconvert.Interface([]interface{}{"true"}), - False: testconvert.Interface([]interface{}{"false"}), - TrackEvents: testconvert.Bool(false), - }, nil), - }, - want: []interface{}{"false"}, - wantErr: false, - expectedLog: "^$", - }, { name: "Get sdk default value if offline", args: args{ @@ -626,7 +805,7 @@ func TestJSONArrayVariation(t *testing.T) { flagKey: "disable-flag", user: ffuser.NewUser("random-key"), defaultValue: []interface{}{"toto"}, - cacheMock: NewCacheMock(&flagv1.FlagData{ + cacheMock: NewCacheMock(&flag.InternalFlag{ Disable: testconvert.Bool(true), }, nil), }, @@ -692,7 +871,7 @@ func TestJSONVariation(t *testing.T) { flagKey: "disable-flag", user: ffuser.NewUser("random-key"), defaultValue: map[string]interface{}{"default-notkey": true}, - cacheMock: NewCacheMock(&flagv1.FlagData{ + cacheMock: NewCacheMock(&flag.InternalFlag{ Disable: testconvert.Bool(true), }, nil), }, @@ -707,7 +886,7 @@ func TestJSONVariation(t *testing.T) { user: ffuser.NewUser("random-key"), defaultValue: map[string]interface{}{"default-notkey": true}, cacheMock: NewCacheMock( - &flagv1.FlagData{}, + &flag.InternalFlag{}, errors.New("impossible to read the toggle before the initialisation")), }, want: map[string]interface{}{"default-notkey": true}, @@ -720,7 +899,7 @@ func TestJSONVariation(t *testing.T) { flagKey: "key-not-exist", user: ffuser.NewUser("random-key"), defaultValue: map[string]interface{}{"default-notkey": true}, - cacheMock: NewCacheMock(&flagv1.FlagData{}, errors.New("flag [key-not-exist] does not exists")), + cacheMock: NewCacheMock(&flag.InternalFlag{}, errors.New("flag [key-not-exist] does not exists")), }, want: map[string]interface{}{"default-notkey": true}, wantErr: true, @@ -732,12 +911,26 @@ func TestJSONVariation(t *testing.T) { flagKey: "test-flag", user: ffuser.NewUser("random-key"), defaultValue: map[string]interface{}{"default-notkey": true}, - cacheMock: NewCacheMock(&flagv1.FlagData{ - Rule: testconvert.String("key eq \"key\""), - Percentage: testconvert.Float64(100), - Default: testconvert.Interface(map[string]interface{}{"default": true}), - True: testconvert.Interface(map[string]interface{}{"true": true}), - False: testconvert.Interface(map[string]interface{}{"false": true}), + cacheMock: NewCacheMock(&flag.InternalFlag{ + Rules: &[]flag.Rule{ + { + Name: testconvert.String("legacyRuleV0"), + Query: testconvert.String("key eq \"key\""), + Percentages: &map[string]float64{ + "False": 0, + "True": 100, + }, + }, + }, + Variations: &map[string]*interface{}{ + "Default": testconvert.Interface(map[string]interface{}{"default": true}), + "True": testconvert.Interface(map[string]interface{}{"true": true}), + "False": testconvert.Interface(map[string]interface{}{"false": true}), + }, + DefaultRule: &flag.Rule{ + Name: testconvert.String("legacyDefaultRule"), + VariationResult: testconvert.String("Default"), + }, }, nil), }, want: map[string]interface{}{"default": true}, @@ -750,12 +943,26 @@ func TestJSONVariation(t *testing.T) { flagKey: "test-flag", user: ffuser.NewAnonymousUser("random-key"), defaultValue: map[string]interface{}{"default-notkey": true}, - cacheMock: NewCacheMock(&flagv1.FlagData{ - Rule: testconvert.String("key eq \"random-key\""), - Percentage: testconvert.Float64(100), - Default: testconvert.Interface(map[string]interface{}{"default": true}), - True: testconvert.Interface(map[string]interface{}{"true": true}), - False: testconvert.Interface(map[string]interface{}{"false": true}), + cacheMock: NewCacheMock(&flag.InternalFlag{ + Rules: &[]flag.Rule{ + { + Name: testconvert.String("legacyRuleV0"), + Query: testconvert.String("key eq \"random-key\""), + Percentages: &map[string]float64{ + "False": 0, + "True": 100, + }, + }, + }, + Variations: &map[string]*interface{}{ + "Default": testconvert.Interface(map[string]interface{}{"default": true}), + "True": testconvert.Interface(map[string]interface{}{"true": true}), + "False": testconvert.Interface(map[string]interface{}{"false": true}), + }, + DefaultRule: &flag.Rule{ + Name: testconvert.String("legacyDefaultRule"), + VariationResult: testconvert.String("Default"), + }, }, nil), }, want: map[string]interface{}{"true": true}, @@ -768,12 +975,26 @@ func TestJSONVariation(t *testing.T) { flagKey: "test-flag", user: ffuser.NewAnonymousUser("random-key-ssss1"), defaultValue: map[string]interface{}{"default-notkey": true}, - cacheMock: NewCacheMock(&flagv1.FlagData{ - Rule: testconvert.String("anonymous eq true"), - Percentage: testconvert.Float64(10), - Default: testconvert.Interface(map[string]interface{}{"default": true}), - True: testconvert.Interface(map[string]interface{}{"true": true}), - False: testconvert.Interface(map[string]interface{}{"false": true}), + cacheMock: NewCacheMock(&flag.InternalFlag{ + Rules: &[]flag.Rule{ + { + Name: testconvert.String("legacyRuleV0"), + Query: testconvert.String("anonymous eq true"), + Percentages: &map[string]float64{ + "False": 90, + "True": 10, + }, + }, + }, + Variations: &map[string]*interface{}{ + "Default": testconvert.Interface(map[string]interface{}{"default": true}), + "True": testconvert.Interface(map[string]interface{}{"true": true}), + "False": testconvert.Interface(map[string]interface{}{"false": true}), + }, + DefaultRule: &flag.Rule{ + Name: testconvert.String("legacyDefaultRule"), + VariationResult: testconvert.String("Default"), + }, }, nil), }, want: map[string]interface{}{"false": true}, @@ -786,11 +1007,26 @@ func TestJSONVariation(t *testing.T) { flagKey: "test-flag", user: ffuser.NewUser("random-key-ssss1"), defaultValue: map[string]interface{}{"default-notkey": true}, - cacheMock: NewCacheMock(&flagv1.FlagData{ - Percentage: testconvert.Float64(100), - Default: testconvert.Interface("xxx"), - True: testconvert.Interface("xxx"), - False: testconvert.Interface("xxx"), + cacheMock: NewCacheMock(&flag.InternalFlag{ + Rules: &[]flag.Rule{ + { + Name: testconvert.String("legacyRuleV0"), + Query: testconvert.String("key eq \"key\""), + Percentages: &map[string]float64{ + "False": 0, + "True": 100, + }, + }, + }, + Variations: &map[string]*interface{}{ + "Default": testconvert.Interface("xxx"), + "False": testconvert.Interface("xxx"), + "True": testconvert.Interface("xxx"), + }, + DefaultRule: &flag.Rule{ + Name: testconvert.String("legacyDefaultRule"), + VariationResult: testconvert.String("Default"), + }, }, nil), }, want: map[string]interface{}{"default-notkey": true}, @@ -804,7 +1040,7 @@ func TestJSONVariation(t *testing.T) { flagKey: "disable-flag", user: ffuser.NewUser("random-key"), defaultValue: map[string]interface{}{"default-notkey": true}, - cacheMock: NewCacheMock(&flagv1.FlagData{ + cacheMock: NewCacheMock(&flag.InternalFlag{ Disable: testconvert.Bool(true), }, nil), }, @@ -875,7 +1111,7 @@ func TestStringVariation(t *testing.T) { flagKey: "disable-flag", user: ffuser.NewUser("random-key"), defaultValue: "default-notkey", - cacheMock: NewCacheMock(&flagv1.FlagData{ + cacheMock: NewCacheMock(&flag.InternalFlag{ Disable: testconvert.Bool(true), }, nil), }, @@ -890,7 +1126,7 @@ func TestStringVariation(t *testing.T) { user: ffuser.NewUser("random-key"), defaultValue: "default-notkey", cacheMock: NewCacheMock( - &flagv1.FlagData{}, + &flag.InternalFlag{}, errors.New("impossible to read the toggle before the initialisation")), }, want: "default-notkey", @@ -903,7 +1139,7 @@ func TestStringVariation(t *testing.T) { flagKey: "key-not-exist", user: ffuser.NewUser("random-key"), defaultValue: "default-notkey", - cacheMock: NewCacheMock(&flagv1.FlagData{}, errors.New("flag [key-not-exist] does not exists")), + cacheMock: NewCacheMock(&flag.InternalFlag{}, errors.New("flag [key-not-exist] does not exists")), }, want: "default-notkey", wantErr: true, @@ -916,12 +1152,26 @@ func TestStringVariation(t *testing.T) { flagKey: "test-flag", user: ffuser.NewUser("random-key"), defaultValue: "default-notkey", - cacheMock: NewCacheMock(&flagv1.FlagData{ - Rule: testconvert.String("key eq \"key\""), - Percentage: testconvert.Float64(100), - Default: testconvert.Interface("default"), - True: testconvert.Interface("true"), - False: testconvert.Interface("false"), + cacheMock: NewCacheMock(&flag.InternalFlag{ + Rules: &[]flag.Rule{ + { + Name: testconvert.String("legacyRuleV0"), + Query: testconvert.String("key eq \"key\""), + Percentages: &map[string]float64{ + "False": 0, + "True": 100, + }, + }, + }, + Variations: &map[string]*interface{}{ + "Default": testconvert.Interface("default"), + "True": testconvert.Interface("true"), + "False": testconvert.Interface("false"), + }, + DefaultRule: &flag.Rule{ + Name: testconvert.String("legacyDefaultRule"), + VariationResult: testconvert.String("Default"), + }, }, nil), }, want: "default", @@ -934,12 +1184,26 @@ func TestStringVariation(t *testing.T) { flagKey: "test-flag", user: ffuser.NewAnonymousUser("random-key"), defaultValue: "default-notkey", - cacheMock: NewCacheMock(&flagv1.FlagData{ - Rule: testconvert.String("key eq \"random-key\""), - Percentage: testconvert.Float64(100), - Default: testconvert.Interface("default"), - True: testconvert.Interface("true"), - False: testconvert.Interface("false"), + cacheMock: NewCacheMock(&flag.InternalFlag{ + Rules: &[]flag.Rule{ + { + Name: testconvert.String("legacyRuleV0"), + Query: testconvert.String("key eq \"random-key\""), + Percentages: &map[string]float64{ + "False": 0, + "True": 100, + }, + }, + }, + Variations: &map[string]*interface{}{ + "Default": testconvert.Interface("default"), + "True": testconvert.Interface("true"), + "False": testconvert.Interface("false"), + }, + DefaultRule: &flag.Rule{ + Name: testconvert.String("legacyDefaultRule"), + VariationResult: testconvert.String("Default"), + }, }, nil), }, want: "true", @@ -952,12 +1216,26 @@ func TestStringVariation(t *testing.T) { flagKey: "test-flag", user: ffuser.NewAnonymousUser("random-key-ssss1"), defaultValue: "default-notkey", - cacheMock: NewCacheMock(&flagv1.FlagData{ - Rule: testconvert.String("anonymous eq true"), - Percentage: testconvert.Float64(10), - Default: testconvert.Interface("default"), - True: testconvert.Interface("true"), - False: testconvert.Interface("false"), + cacheMock: NewCacheMock(&flag.InternalFlag{ + Rules: &[]flag.Rule{ + { + Name: testconvert.String("legacyRuleV0"), + Query: testconvert.String("anonymous eq true"), + Percentages: &map[string]float64{ + "False": 90, + "True": 10, + }, + }, + }, + Variations: &map[string]*interface{}{ + "Default": testconvert.Interface("default"), + "True": testconvert.Interface("true"), + "False": testconvert.Interface("false"), + }, + DefaultRule: &flag.Rule{ + Name: testconvert.String("legacyDefaultRule"), + VariationResult: testconvert.String("Default"), + }, }, nil), }, want: "false", @@ -970,12 +1248,26 @@ func TestStringVariation(t *testing.T) { flagKey: "test-flag", user: ffuser.NewUser("random-key-ssss1"), defaultValue: "default-notkey", - cacheMock: NewCacheMock(&flagv1.FlagData{ - Rule: testconvert.String("anonymous eq true"), - Percentage: testconvert.Float64(50), - Default: testconvert.Interface(111), - True: testconvert.Interface(112), - False: testconvert.Interface(113), + cacheMock: NewCacheMock(&flag.InternalFlag{ + Rules: &[]flag.Rule{ + { + Name: testconvert.String("legacyRuleV0"), + Query: testconvert.String("key eq \"key\""), + Percentages: &map[string]float64{ + "False": 0, + "True": 100, + }, + }, + }, + Variations: &map[string]*interface{}{ + "Default": testconvert.Interface(1), + "False": testconvert.Interface(2), + "True": testconvert.Interface(3), + }, + DefaultRule: &flag.Rule{ + Name: testconvert.String("legacyDefaultRule"), + VariationResult: testconvert.String("Default"), + }, }, nil), }, want: "default-notkey", @@ -989,7 +1281,7 @@ func TestStringVariation(t *testing.T) { flagKey: "disable-flag", user: ffuser.NewUser("random-key"), defaultValue: "default-notkey", - cacheMock: NewCacheMock(&flagv1.FlagData{ + cacheMock: NewCacheMock(&flag.InternalFlag{ Disable: testconvert.Bool(true), }, nil), }, @@ -1059,7 +1351,7 @@ func TestIntVariation(t *testing.T) { flagKey: "disable-flag", user: ffuser.NewUser("random-key"), defaultValue: 125, - cacheMock: NewCacheMock(&flagv1.FlagData{ + cacheMock: NewCacheMock(&flag.InternalFlag{ Disable: testconvert.Bool(true), }, nil), }, @@ -1074,7 +1366,7 @@ func TestIntVariation(t *testing.T) { user: ffuser.NewUser("random-key"), defaultValue: 118, cacheMock: NewCacheMock( - &flagv1.FlagData{}, + &flag.InternalFlag{}, errors.New("impossible to read the toggle before the initialisation")), }, want: 118, @@ -1087,7 +1379,7 @@ func TestIntVariation(t *testing.T) { flagKey: "key-not-exist", user: ffuser.NewUser("random-key"), defaultValue: 118, - cacheMock: NewCacheMock(&flagv1.FlagData{}, errors.New("flag [key-not-exist] does not exists")), + cacheMock: NewCacheMock(&flag.InternalFlag{}, errors.New("flag [key-not-exist] does not exists")), }, want: 118, wantErr: true, @@ -1099,12 +1391,26 @@ func TestIntVariation(t *testing.T) { flagKey: "test-flag", user: ffuser.NewUser("random-key"), defaultValue: 118, - cacheMock: NewCacheMock(&flagv1.FlagData{ - Rule: testconvert.String("key eq \"key\""), - Percentage: testconvert.Float64(100), - Default: testconvert.Interface(119), - True: testconvert.Interface(120), - False: testconvert.Interface(121), + cacheMock: NewCacheMock(&flag.InternalFlag{ + Rules: &[]flag.Rule{ + { + Name: testconvert.String("legacyRuleV0"), + Query: testconvert.String("key eq \"key\""), + Percentages: &map[string]float64{ + "False": 0, + "True": 100, + }, + }, + }, + Variations: &map[string]*interface{}{ + "Default": testconvert.Interface(119), + "True": testconvert.Interface(120), + "False": testconvert.Interface(121), + }, + DefaultRule: &flag.Rule{ + Name: testconvert.String("legacyDefaultRule"), + VariationResult: testconvert.String("Default"), + }, }, nil), }, want: 119, @@ -1117,12 +1423,26 @@ func TestIntVariation(t *testing.T) { flagKey: "test-flag", user: ffuser.NewAnonymousUser("random-key"), defaultValue: 118, - cacheMock: NewCacheMock(&flagv1.FlagData{ - Rule: testconvert.String("key eq \"random-key\""), - Percentage: testconvert.Float64(100), - Default: testconvert.Interface(119), - True: testconvert.Interface(120), - False: testconvert.Interface(121), + cacheMock: NewCacheMock(&flag.InternalFlag{ + Rules: &[]flag.Rule{ + { + Name: testconvert.String("legacyRuleV0"), + Query: testconvert.String("key eq \"random-key\""), + Percentages: &map[string]float64{ + "False": 0, + "True": 100, + }, + }, + }, + Variations: &map[string]*interface{}{ + "Default": testconvert.Interface(119), + "True": testconvert.Interface(120), + "False": testconvert.Interface(121), + }, + DefaultRule: &flag.Rule{ + Name: testconvert.String("legacyDefaultRule"), + VariationResult: testconvert.String("Default"), + }, }, nil), }, want: 120, @@ -1135,12 +1455,26 @@ func TestIntVariation(t *testing.T) { flagKey: "test-flag", user: ffuser.NewAnonymousUser("random-key-ssss1"), defaultValue: 118, - cacheMock: NewCacheMock(&flagv1.FlagData{ - Rule: testconvert.String("anonymous eq true"), - Percentage: testconvert.Float64(10), - Default: testconvert.Interface(119), - True: testconvert.Interface(120), - False: testconvert.Interface(121), + cacheMock: NewCacheMock(&flag.InternalFlag{ + Rules: &[]flag.Rule{ + { + Name: testconvert.String("legacyRuleV0"), + Query: testconvert.String("anonymous eq true"), + Percentages: &map[string]float64{ + "False": 90, + "True": 10, + }, + }, + }, + Variations: &map[string]*interface{}{ + "Default": testconvert.Interface(119), + "True": testconvert.Interface(120), + "False": testconvert.Interface(121), + }, + DefaultRule: &flag.Rule{ + Name: testconvert.String("legacyDefaultRule"), + VariationResult: testconvert.String("Default"), + }, }, nil), }, want: 121, @@ -1153,12 +1487,26 @@ func TestIntVariation(t *testing.T) { flagKey: "test-flag", user: ffuser.NewUser("random-key-ssss1"), defaultValue: 118, - cacheMock: NewCacheMock(&flagv1.FlagData{ - Rule: testconvert.String("anonymous eq true"), - Percentage: testconvert.Float64(50), - Default: testconvert.Interface("default"), - True: testconvert.Interface("true"), - False: testconvert.Interface("false"), + cacheMock: NewCacheMock(&flag.InternalFlag{ + Rules: &[]flag.Rule{ + { + Name: testconvert.String("legacyRuleV0"), + Query: testconvert.String("key eq \"key\""), + Percentages: &map[string]float64{ + "False": 0, + "True": 100, + }, + }, + }, + Variations: &map[string]*interface{}{ + "Default": testconvert.Interface("xxx"), + "False": testconvert.Interface("xxx"), + "True": testconvert.Interface("xxx"), + }, + DefaultRule: &flag.Rule{ + Name: testconvert.String("legacyDefaultRule"), + VariationResult: testconvert.String("Default"), + }, }, nil), }, want: 118, @@ -1171,12 +1519,26 @@ func TestIntVariation(t *testing.T) { flagKey: "test-flag", user: ffuser.NewAnonymousUser("random-key"), defaultValue: 118, - cacheMock: NewCacheMock(&flagv1.FlagData{ - Rule: testconvert.String("key eq \"random-key\""), - Percentage: testconvert.Float64(100), - Default: testconvert.Interface(119.1), - True: testconvert.Interface(120.1), - False: testconvert.Interface(121.1), + cacheMock: NewCacheMock(&flag.InternalFlag{ + Rules: &[]flag.Rule{ + { + Name: testconvert.String("legacyRuleV0"), + Query: testconvert.String("key eq \"random-key\""), + Percentages: &map[string]float64{ + "False": 0, + "True": 100, + }, + }, + }, + Variations: &map[string]*interface{}{ + "Default": testconvert.Interface(119.1), + "True": testconvert.Interface(120.1), + "False": testconvert.Interface(121.1), + }, + DefaultRule: &flag.Rule{ + Name: testconvert.String("legacyDefaultRule"), + VariationResult: testconvert.String("Default"), + }, }, nil), }, want: 120, @@ -1190,7 +1552,7 @@ func TestIntVariation(t *testing.T) { flagKey: "disable-flag", user: ffuser.NewUser("random-key"), defaultValue: 125, - cacheMock: NewCacheMock(&flagv1.FlagData{ + cacheMock: NewCacheMock(&flag.InternalFlag{ Disable: testconvert.Bool(true), }, nil), }, @@ -1416,7 +1778,7 @@ func TestRawVariation(t *testing.T) { flagKey: "disable-flag", user: ffuser.NewUser("random-key"), defaultValue: true, - cacheMock: NewCacheMock(&flagv1.FlagData{ + cacheMock: NewCacheMock(&flag.InternalFlag{ Disable: testconvert.Bool(true), }, nil), }, @@ -1439,7 +1801,7 @@ func TestRawVariation(t *testing.T) { user: ffuser.NewUser("random-key"), defaultValue: "defaultValue", cacheMock: NewCacheMock( - &flagv1.FlagData{}, + &flag.InternalFlag{}, errors.New("impossible to read the toggle before the initialisation")), }, want: model.RawVarResult{ @@ -1461,7 +1823,7 @@ func TestRawVariation(t *testing.T) { flagKey: "key-not-exist", user: ffuser.NewUser("random-key"), defaultValue: 123456, - cacheMock: NewCacheMock(&flagv1.FlagData{}, errors.New("flag [key-not-exist] does not exists")), + cacheMock: NewCacheMock(&flag.InternalFlag{}, errors.New("flag [key-not-exist] does not exists")), }, want: model.RawVarResult{ Value: 123456, @@ -1482,12 +1844,26 @@ func TestRawVariation(t *testing.T) { flagKey: "test-flag", user: ffuser.NewUser("random-key"), defaultValue: map[string]interface{}{"test123": "test"}, - cacheMock: NewCacheMock(&flagv1.FlagData{ - Rule: testconvert.String("key eq \"key\""), - Percentage: testconvert.Float64(100), - Default: testconvert.Interface(map[string]interface{}{"test": "test"}), - True: testconvert.Interface(map[string]interface{}{"test2": "test"}), - False: testconvert.Interface(map[string]interface{}{"test3": "test"}), + cacheMock: NewCacheMock(&flag.InternalFlag{ + Rules: &[]flag.Rule{ + { + Name: testconvert.String("legacyRuleV0"), + Query: testconvert.String("key eq \"key\""), + Percentages: &map[string]float64{ + "False": 0, + "True": 100, + }, + }, + }, + Variations: &map[string]*interface{}{ + "Default": testconvert.Interface(map[string]interface{}{"test": "test"}), + "True": testconvert.Interface(map[string]interface{}{"test2": "test"}), + "False": testconvert.Interface(map[string]interface{}{"test3": "test"}), + }, + DefaultRule: &flag.Rule{ + Name: testconvert.String("legacyDefaultRule"), + VariationResult: testconvert.String("Default"), + }, }, nil), }, want: model.RawVarResult{ @@ -1508,12 +1884,26 @@ func TestRawVariation(t *testing.T) { flagKey: "test-flag", user: ffuser.NewAnonymousUser("random-key"), defaultValue: map[string]interface{}{"test123": "test"}, - cacheMock: NewCacheMock(&flagv1.FlagData{ - Rule: testconvert.String("key eq \"random-key\""), - Percentage: testconvert.Float64(100), - Default: testconvert.Interface(map[string]interface{}{"test": "test"}), - True: testconvert.Interface(map[string]interface{}{"test2": "test"}), - False: testconvert.Interface(map[string]interface{}{"test3": "test"}), + cacheMock: NewCacheMock(&flag.InternalFlag{ + Rules: &[]flag.Rule{ + { + Name: testconvert.String("legacyRuleV0"), + Query: testconvert.String("key eq \"random-key\""), + Percentages: &map[string]float64{ + "False": 0, + "True": 100, + }, + }, + }, + Variations: &map[string]*interface{}{ + "Default": testconvert.Interface(map[string]interface{}{"test": "test"}), + "True": testconvert.Interface(map[string]interface{}{"test2": "test"}), + "False": testconvert.Interface(map[string]interface{}{"test3": "test"}), + }, + DefaultRule: &flag.Rule{ + Name: testconvert.String("legacyDefaultRule"), + VariationResult: testconvert.String("Default"), + }, }, nil), }, want: model.RawVarResult{ @@ -1522,7 +1912,7 @@ func TestRawVariation(t *testing.T) { VariationType: "True", Failed: false, TrackEvents: true, - Reason: flag.ReasonSplit, + Reason: flag.ReasonTargetingMatch, }, }, wantErr: false, @@ -1534,12 +1924,26 @@ func TestRawVariation(t *testing.T) { flagKey: "test-flag", user: ffuser.NewAnonymousUser("random-key-ssss1"), defaultValue: map[string]interface{}{"test123": "test"}, - cacheMock: NewCacheMock(&flagv1.FlagData{ - Rule: testconvert.String("anonymous eq true"), - Percentage: testconvert.Float64(10), - Default: testconvert.Interface(map[string]interface{}{"test": "test"}), - True: testconvert.Interface(map[string]interface{}{"test2": "test"}), - False: testconvert.Interface(map[string]interface{}{"test3": "test"}), + cacheMock: NewCacheMock(&flag.InternalFlag{ + Rules: &[]flag.Rule{ + { + Name: testconvert.String("legacyRuleV0"), + Query: testconvert.String("anonymous eq true"), + Percentages: &map[string]float64{ + "False": 90, + "True": 10, + }, + }, + }, + Variations: &map[string]*interface{}{ + "Default": testconvert.Interface(map[string]interface{}{"test": "test"}), + "True": testconvert.Interface(map[string]interface{}{"test2": "test"}), + "False": testconvert.Interface(map[string]interface{}{"test3": "test"}), + }, + DefaultRule: &flag.Rule{ + Name: testconvert.String("legacyDefaultRule"), + VariationResult: testconvert.String("Default"), + }, }, nil), }, want: model.RawVarResult{ @@ -1548,7 +1952,7 @@ func TestRawVariation(t *testing.T) { VariationType: "False", Failed: false, TrackEvents: true, - Reason: flag.ReasonSplit, + Reason: flag.ReasonTargetingMatch, }, }, wantErr: false, @@ -1560,12 +1964,26 @@ func TestRawVariation(t *testing.T) { flagKey: "test-flag", user: ffuser.NewAnonymousUser("random-key"), defaultValue: true, - cacheMock: NewCacheMock(&flagv1.FlagData{ - Rule: testconvert.String("key eq \"random-key\""), - Percentage: testconvert.Float64(100), - True: testconvert.Interface(true), - False: testconvert.Interface(false), - Default: testconvert.Interface(false), + cacheMock: NewCacheMock(&flag.InternalFlag{ + Variations: &map[string]*interface{}{ + "Default": testconvert.Interface(false), + "True": testconvert.Interface(true), + "False": testconvert.Interface(false), + }, + Rules: &[]flag.Rule{ + { + Name: testconvert.String("legacyRuleV0"), + Query: testconvert.String("key eq \"random-key\""), + Percentages: &map[string]float64{ + "False": 0, + "True": 100, + }, + }, + }, + DefaultRule: &flag.Rule{ + Name: testconvert.String("legacyDefaultRule"), + VariationResult: testconvert.String("Default"), + }, TrackEvents: testconvert.Bool(false), }, nil), }, @@ -1575,7 +1993,7 @@ func TestRawVariation(t *testing.T) { VariationType: "True", Failed: false, TrackEvents: false, - Reason: flag.ReasonSplit, + Reason: flag.ReasonTargetingMatch, }, }, wantErr: false, @@ -1588,7 +2006,7 @@ func TestRawVariation(t *testing.T) { flagKey: "disable-flag", user: ffuser.NewUser("random-key"), defaultValue: false, - cacheMock: NewCacheMock(&flagv1.FlagData{ + cacheMock: NewCacheMock(&flag.InternalFlag{ Disable: testconvert.Bool(true), }, nil), }, From ae0b31345ecfdb1257f0c17bdfef385112aae739 Mon Sep 17 00:00:00 2001 From: Thomas Poignant Date: Fri, 29 Jul 2022 18:14:07 +0200 Subject: [PATCH 09/50] Remove usage of flagv1.FlagData Signed-off-by: Thomas Poignant --- internal/cache/notification_service_test.go | 219 ++++++++++++++------ internal/toremove/toremove.go | 10 +- variation_test.go | 3 +- 3 files changed, 163 insertions(+), 69 deletions(-) diff --git a/internal/cache/notification_service_test.go b/internal/cache/notification_service_test.go index d803b9fd641..79109854d07 100644 --- a/internal/cache/notification_service_test.go +++ b/internal/cache/notification_service_test.go @@ -6,7 +6,6 @@ import ( "github.com/stretchr/testify/assert" "github.com/thomaspoignant/go-feature-flag/internal/flag" - flagv1 "github.com/thomaspoignant/go-feature-flag/internal/flagv1" "github.com/thomaspoignant/go-feature-flag/notifier" "github.com/thomaspoignant/go-feature-flag/testutils/testconvert" ) @@ -29,35 +28,67 @@ func Test_notificationService_getDifferences(t *testing.T) { name: "Delete flag", args: args{ oldCache: map[string]flag.Flag{ - "test-flag": &flagv1.FlagData{ - Percentage: testconvert.Float64(100), - True: testconvert.Interface(true), - False: testconvert.Interface(false), - Default: testconvert.Interface(false), + "test-flag": &flag.InternalFlag{ + Variations: &map[string]*interface{}{ + "Default": testconvert.Interface(false), + "False": testconvert.Interface(false), + "True": testconvert.Interface(true), + }, + DefaultRule: &flag.Rule{ + Name: testconvert.String("legacyRuleV0"), + Percentages: &map[string]float64{ + "False": 0, + "True": 100, + }, + }, }, - "test-flag2": &flagv1.FlagData{ - Percentage: testconvert.Float64(100), - True: testconvert.Interface(true), - False: testconvert.Interface(false), - Default: testconvert.Interface(false), + "test-flag2": &flag.InternalFlag{ + Variations: &map[string]*interface{}{ + "Default": testconvert.Interface(false), + "False": testconvert.Interface(false), + "True": testconvert.Interface(true), + }, + DefaultRule: &flag.Rule{ + Name: testconvert.String("legacyRuleV0"), + Percentages: &map[string]float64{ + "False": 0, + "True": 100, + }, + }, }, }, newCache: map[string]flag.Flag{ - "test-flag": &flagv1.FlagData{ - Percentage: testconvert.Float64(100), - True: testconvert.Interface(true), - False: testconvert.Interface(false), - Default: testconvert.Interface(false), + "test-flag": &flag.InternalFlag{ + Variations: &map[string]*interface{}{ + "Default": testconvert.Interface(false), + "False": testconvert.Interface(false), + "True": testconvert.Interface(true), + }, + DefaultRule: &flag.Rule{ + Name: testconvert.String("legacyRuleV0"), + Percentages: &map[string]float64{ + "False": 0, + "True": 100, + }, + }, }, }, }, want: notifier.DiffCache{ Deleted: map[string]flag.Flag{ - "test-flag2": &flagv1.FlagData{ - Percentage: testconvert.Float64(100), - True: testconvert.Interface(true), - False: testconvert.Interface(false), - Default: testconvert.Interface(false), + "test-flag2": &flag.InternalFlag{ + Variations: &map[string]*interface{}{ + "Default": testconvert.Interface(false), + "False": testconvert.Interface(false), + "True": testconvert.Interface(true), + }, + DefaultRule: &flag.Rule{ + Name: testconvert.String("legacyRuleV0"), + Percentages: &map[string]float64{ + "False": 0, + "True": 100, + }, + }, }, }, Added: map[string]flag.Flag{}, @@ -68,35 +99,67 @@ func Test_notificationService_getDifferences(t *testing.T) { name: "Added flag", args: args{ oldCache: map[string]flag.Flag{ - "test-flag": &flagv1.FlagData{ - Percentage: testconvert.Float64(100), - True: testconvert.Interface(true), - False: testconvert.Interface(false), - Default: testconvert.Interface(false), + "test-flag": &flag.InternalFlag{ + Variations: &map[string]*interface{}{ + "Default": testconvert.Interface(false), + "False": testconvert.Interface(false), + "True": testconvert.Interface(true), + }, + DefaultRule: &flag.Rule{ + Name: testconvert.String("legacyRuleV0"), + Percentages: &map[string]float64{ + "False": 0, + "True": 100, + }, + }, }, }, newCache: map[string]flag.Flag{ - "test-flag": &flagv1.FlagData{ - Percentage: testconvert.Float64(100), - True: testconvert.Interface(true), - False: testconvert.Interface(false), - Default: testconvert.Interface(false), + "test-flag": &flag.InternalFlag{ + Variations: &map[string]*interface{}{ + "Default": testconvert.Interface(false), + "False": testconvert.Interface(false), + "True": testconvert.Interface(true), + }, + DefaultRule: &flag.Rule{ + Name: testconvert.String("legacyRuleV0"), + Percentages: &map[string]float64{ + "False": 0, + "True": 100, + }, + }, }, - "test-flag2": &flagv1.FlagData{ - Percentage: testconvert.Float64(100), - True: testconvert.Interface(true), - False: testconvert.Interface(false), - Default: testconvert.Interface(false), + "test-flag2": &flag.InternalFlag{ + Variations: &map[string]*interface{}{ + "Default": testconvert.Interface(false), + "False": testconvert.Interface(false), + "True": testconvert.Interface(true), + }, + DefaultRule: &flag.Rule{ + Name: testconvert.String("legacyRuleV0"), + Percentages: &map[string]float64{ + "False": 0, + "True": 100, + }, + }, }, }, }, want: notifier.DiffCache{ Added: map[string]flag.Flag{ - "test-flag2": &flagv1.FlagData{ - Percentage: testconvert.Float64(100), - True: testconvert.Interface(true), - False: testconvert.Interface(false), - Default: testconvert.Interface(false), + "test-flag2": &flag.InternalFlag{ + Variations: &map[string]*interface{}{ + "Default": testconvert.Interface(false), + "False": testconvert.Interface(false), + "True": testconvert.Interface(true), + }, + DefaultRule: &flag.Rule{ + Name: testconvert.String("legacyRuleV0"), + Percentages: &map[string]float64{ + "False": 0, + "True": 100, + }, + }, }, }, Deleted: map[string]flag.Flag{}, @@ -107,19 +170,35 @@ func Test_notificationService_getDifferences(t *testing.T) { name: "Updated flag", args: args{ oldCache: map[string]flag.Flag{ - "test-flag": &flagv1.FlagData{ - Percentage: testconvert.Float64(100), - True: testconvert.Interface(true), - False: testconvert.Interface(false), - Default: testconvert.Interface(false), + "test-flag": &flag.InternalFlag{ + Variations: &map[string]*interface{}{ + "Default": testconvert.Interface(false), + "False": testconvert.Interface(false), + "True": testconvert.Interface(true), + }, + DefaultRule: &flag.Rule{ + Name: testconvert.String("legacyRuleV0"), + Percentages: &map[string]float64{ + "False": 0, + "True": 100, + }, + }, }, }, newCache: map[string]flag.Flag{ - "test-flag": &flagv1.FlagData{ - Percentage: testconvert.Float64(100), - True: testconvert.Interface(true), - False: testconvert.Interface(false), - Default: testconvert.Interface(true), + "test-flag": &flag.InternalFlag{ + Variations: &map[string]*interface{}{ + "Default": testconvert.Interface(true), + "False": testconvert.Interface(false), + "True": testconvert.Interface(true), + }, + DefaultRule: &flag.Rule{ + Name: testconvert.String("legacyRuleV0"), + Percentages: &map[string]float64{ + "False": 0, + "True": 100, + }, + }, }, }, }, @@ -128,17 +207,33 @@ func Test_notificationService_getDifferences(t *testing.T) { Deleted: map[string]flag.Flag{}, Updated: map[string]notifier.DiffUpdated{ "test-flag": { - Before: &flagv1.FlagData{ - Percentage: testconvert.Float64(100), - True: testconvert.Interface(true), - False: testconvert.Interface(false), - Default: testconvert.Interface(false), - }, - After: &flagv1.FlagData{ - Percentage: testconvert.Float64(100), - True: testconvert.Interface(true), - False: testconvert.Interface(false), - Default: testconvert.Interface(true), + Before: &flag.InternalFlag{ + Variations: &map[string]*interface{}{ + "Default": testconvert.Interface(false), + "False": testconvert.Interface(false), + "True": testconvert.Interface(true), + }, + DefaultRule: &flag.Rule{ + Name: testconvert.String("legacyRuleV0"), + Percentages: &map[string]float64{ + "False": 0, + "True": 100, + }, + }, + }, + After: &flag.InternalFlag{ + Variations: &map[string]*interface{}{ + "Default": testconvert.Interface(true), + "False": testconvert.Interface(false), + "True": testconvert.Interface(true), + }, + DefaultRule: &flag.Rule{ + Name: testconvert.String("legacyRuleV0"), + Percentages: &map[string]float64{ + "False": 0, + "True": 100, + }, + }, }, }, }, diff --git a/internal/toremove/toremove.go b/internal/toremove/toremove.go index 66494bc7b4c..e19b305cba9 100644 --- a/internal/toremove/toremove.go +++ b/internal/toremove/toremove.go @@ -12,12 +12,10 @@ func main() { t := map[string]dto.DTO{ "test-flag": { DTOv0: dto.DTOv0{ - Rule: testconvert.String("key eq \"random-key\""), - Percentage: testconvert.Float64(100), - True: testconvert.Interface(true), - False: testconvert.Interface(false), - Default: testconvert.Interface(false), - TrackEvents: testconvert.Bool(false), + Percentage: testconvert.Float64(100), + True: testconvert.Interface(true), + False: testconvert.Interface(false), + Default: testconvert.Interface(false), }, }, } diff --git a/variation_test.go b/variation_test.go index 596d70f20a7..31ec229d051 100644 --- a/variation_test.go +++ b/variation_test.go @@ -4,13 +4,14 @@ import ( "context" "encoding/json" "errors" - "github.com/thomaspoignant/go-feature-flag/internal/model" "io/ioutil" "log" "os" "testing" "time" + "github.com/thomaspoignant/go-feature-flag/internal/model" + "github.com/thomaspoignant/go-feature-flag/exporter/fileexporter" "github.com/thomaspoignant/go-feature-flag/exporter/logsexporter" From cd84bf913e391a7cc034ada67e36c14d074eb89f Mon Sep 17 00:00:00 2001 From: Thomas Poignant Date: Fri, 29 Jul 2022 18:46:31 +0200 Subject: [PATCH 10/50] continue to remove flagv1 Signed-off-by: Thomas Poignant --- internal/dataexporter/data_exporter_test.go | 11 +- internal/dto/converter_v0.go | 23 +- internal/toremove/toremove.go | 1 - notifier/diff_cache_test.go | 145 +++++++++---- notifier/logsnotifier/notifier.go | 4 +- notifier/logsnotifier/notifier_test.go | 201 +++++++++++++----- notifier/slacknotifier/notifier_test.go | 107 +++++++--- ...d_call_webhook_and_have_valid_results.json | 43 ++-- 8 files changed, 383 insertions(+), 152 deletions(-) diff --git a/internal/dataexporter/data_exporter_test.go b/internal/dataexporter/data_exporter_test.go index 8b4f7b0af03..99c77e92b26 100644 --- a/internal/dataexporter/data_exporter_test.go +++ b/internal/dataexporter/data_exporter_test.go @@ -13,7 +13,6 @@ import ( "github.com/stretchr/testify/assert" "github.com/thomaspoignant/go-feature-flag/exporter" - "github.com/thomaspoignant/go-feature-flag/internal/flagv1" "github.com/thomaspoignant/go-feature-flag/testutils/mock" "github.com/thomaspoignant/go-feature-flag/ffuser" @@ -29,7 +28,7 @@ func TestDataExporterScheduler_flushWithTime(t *testing.T) { inputEvents := []exporter.FeatureEvent{ exporter.NewFeatureEvent(ffuser.NewAnonymousUser("ABCD"), "random-key", - "YO", flagv1.VariationDefault, false, ""), + "YO", "defaultVar", false, ""), } for _, event := range inputEvents { @@ -50,7 +49,7 @@ func TestDataExporterScheduler_flushWithNumberOfEvents(t *testing.T) { var inputEvents []exporter.FeatureEvent for i := 0; i <= 100; i++ { inputEvents = append(inputEvents, exporter.NewFeatureEvent(ffuser.NewAnonymousUser("ABCD"), - "random-key", "YO", flagv1.VariationDefault, false, "")) + "random-key", "YO", "defaultVar", false, "")) } for _, event := range inputEvents { dc.AddEvent(event) @@ -68,7 +67,7 @@ func TestDataExporterScheduler_defaultFlush(t *testing.T) { var inputEvents []exporter.FeatureEvent for i := 0; i <= 100000; i++ { inputEvents = append(inputEvents, exporter.NewFeatureEvent(ffuser.NewAnonymousUser("ABCD"), - "random-key", "YO", flagv1.VariationDefault, false, "")) + "random-key", "YO", "defaultVar", false, "")) } for _, event := range inputEvents { dc.AddEvent(event) @@ -92,7 +91,7 @@ func TestDataExporterScheduler_exporterReturnError(t *testing.T) { var inputEvents []exporter.FeatureEvent for i := 0; i <= 200; i++ { inputEvents = append(inputEvents, exporter.NewFeatureEvent(ffuser.NewAnonymousUser("ABCD"), - "random-key", "YO", flagv1.VariationDefault, false, "")) + "random-key", "YO", "defaultVar", false, "")) } for _, event := range inputEvents { dc.AddEvent(event) @@ -113,7 +112,7 @@ func TestDataExporterScheduler_nonBulkExporter(t *testing.T) { var inputEvents []exporter.FeatureEvent for i := 0; i < 100; i++ { inputEvents = append(inputEvents, exporter.NewFeatureEvent(ffuser.NewAnonymousUser("ABCD"), - "random-key", "YO", flagv1.VariationDefault, false, "")) + "random-key", "YO", "defaultVar", false, "")) } for _, event := range inputEvents { dc.AddEvent(event) diff --git a/internal/dto/converter_v0.go b/internal/dto/converter_v0.go index e51fb27a13e..ab89423a7f7 100644 --- a/internal/dto/converter_v0.go +++ b/internal/dto/converter_v0.go @@ -1,6 +1,9 @@ package dto -import "github.com/thomaspoignant/go-feature-flag/internal/flag" +import ( + "github.com/thomaspoignant/go-feature-flag/internal/flag" + "github.com/thomaspoignant/go-feature-flag/internal/flagv1" +) var ( LegacyRuleName = "legacyRuleV0" @@ -46,11 +49,16 @@ func ConvertV0DtoToFlag(d DTO, isScheduleStep bool) flag.InternalFlag { } } + var rollout *flag.Rollout + if d.Rollout != nil { + rollout = convertRollout(*d.Rollout) + } + return flag.InternalFlag{ Variations: variations, Rules: rules, DefaultRule: defaultRule, - Rollout: nil, + Rollout: rollout, TrackEvents: d.TrackEvents, Disable: d.Disable, Version: d.Version, @@ -117,6 +125,17 @@ func createVariationsV0(d DTO, isScheduleStep bool) map[string]*interface{} { return variations } +func convertRollout(rollout flagv1.Rollout) *flag.Rollout { + r := flag.Rollout{} + if rollout.Experimentation != nil && rollout.Experimentation.Start != nil && rollout.Experimentation.End != nil { + r.Experimentation = &flag.ExperimentationRollout{ + Start: rollout.Experimentation.Start, + End: rollout.Experimentation.End, + } + } + return &r +} + func computePercentages(percentage float64) map[string]float64 { return map[string]float64{ trueVariation: percentage, diff --git a/internal/toremove/toremove.go b/internal/toremove/toremove.go index e19b305cba9..8dccd189fab 100644 --- a/internal/toremove/toremove.go +++ b/internal/toremove/toremove.go @@ -2,7 +2,6 @@ package main import ( "fmt" - "github.com/thomaspoignant/go-feature-flag/internal/dto" "github.com/thomaspoignant/go-feature-flag/testutils/testconvert" "gopkg.in/yaml.v2" diff --git a/notifier/diff_cache_test.go b/notifier/diff_cache_test.go index 4278e2840a3..3b73fbd8116 100644 --- a/notifier/diff_cache_test.go +++ b/notifier/diff_cache_test.go @@ -5,7 +5,6 @@ import ( "github.com/stretchr/testify/assert" "github.com/thomaspoignant/go-feature-flag/internal/flag" - flagv1 "github.com/thomaspoignant/go-feature-flag/internal/flagv1" "github.com/thomaspoignant/go-feature-flag/notifier" "github.com/thomaspoignant/go-feature-flag/testutils/testconvert" ) @@ -39,11 +38,19 @@ func TestDiffCache_HasDiff(t *testing.T) { name: "only Deleted", fields: fields{ Deleted: map[string]flag.Flag{ - "flag": &flagv1.FlagData{ - Percentage: testconvert.Float64(100), - True: testconvert.Interface(true), - False: testconvert.Interface(true), - Default: testconvert.Interface(true), + "flag": &flag.InternalFlag{ + Variations: &map[string]*interface{}{ + "Default": testconvert.Interface(true), + "True": testconvert.Interface(true), + "False": testconvert.Interface(true), + }, + DefaultRule: &flag.Rule{ + Name: testconvert.String("legacyDefaultRule"), + Percentages: &map[string]float64{ + "False": 0, + "True": 100, + }, + }, }, }, Added: map[string]flag.Flag{}, @@ -55,11 +62,19 @@ func TestDiffCache_HasDiff(t *testing.T) { name: "only Added", fields: fields{ Added: map[string]flag.Flag{ - "flag": &flagv1.FlagData{ - Percentage: testconvert.Float64(100), - True: testconvert.Interface(true), - False: testconvert.Interface(true), - Default: testconvert.Interface(true), + "flag": &flag.InternalFlag{ + Variations: &map[string]*interface{}{ + "Default": testconvert.Interface(true), + "True": testconvert.Interface(true), + "False": testconvert.Interface(true), + }, + DefaultRule: &flag.Rule{ + Name: testconvert.String("legacyDefaultRule"), + Percentages: &map[string]float64{ + "False": 0, + "True": 100, + }, + }, }, }, Deleted: map[string]flag.Flag{}, @@ -74,17 +89,33 @@ func TestDiffCache_HasDiff(t *testing.T) { Deleted: map[string]flag.Flag{}, Updated: map[string]notifier.DiffUpdated{ "flag": { - Before: &flagv1.FlagData{ - Percentage: testconvert.Float64(100), - True: testconvert.Interface(true), - False: testconvert.Interface(true), - Default: testconvert.Interface(true), + Before: &flag.InternalFlag{ + Variations: &map[string]*interface{}{ + "Default": testconvert.Interface(true), + "True": testconvert.Interface(true), + "False": testconvert.Interface(true), + }, + DefaultRule: &flag.Rule{ + Name: testconvert.String("legacyDefaultRule"), + Percentages: &map[string]float64{ + "False": 0, + "True": 100, + }, + }, }, - After: &flagv1.FlagData{ - Percentage: testconvert.Float64(100), - True: testconvert.Interface(true), - False: testconvert.Interface(true), - Default: testconvert.Interface(false), + After: &flag.InternalFlag{ + Variations: &map[string]*interface{}{ + "Default": testconvert.Interface(false), + "True": testconvert.Interface(true), + "False": testconvert.Interface(true), + }, + DefaultRule: &flag.Rule{ + Name: testconvert.String("legacyDefaultRule"), + Percentages: &map[string]float64{ + "False": 0, + "True": 100, + }, + }, }, }, }, @@ -95,34 +126,66 @@ func TestDiffCache_HasDiff(t *testing.T) { name: "all fields", fields: fields{ Added: map[string]flag.Flag{ - "flag": &flagv1.FlagData{ - Percentage: testconvert.Float64(100), - True: testconvert.Interface(true), - False: testconvert.Interface(true), - Default: testconvert.Interface(true), + "flag": &flag.InternalFlag{ + Variations: &map[string]*interface{}{ + "Default": testconvert.Interface(true), + "True": testconvert.Interface(true), + "False": testconvert.Interface(true), + }, + DefaultRule: &flag.Rule{ + Name: testconvert.String("legacyDefaultRule"), + Percentages: &map[string]float64{ + "False": 0, + "True": 100, + }, + }, }, }, Deleted: map[string]flag.Flag{ - "flag": &flagv1.FlagData{ - Percentage: testconvert.Float64(100), - True: testconvert.Interface(true), - False: testconvert.Interface(true), - Default: testconvert.Interface(true), + "flag": &flag.InternalFlag{ + Variations: &map[string]*interface{}{ + "Default": testconvert.Interface(true), + "True": testconvert.Interface(true), + "False": testconvert.Interface(true), + }, + DefaultRule: &flag.Rule{ + Name: testconvert.String("legacyDefaultRule"), + Percentages: &map[string]float64{ + "False": 0, + "True": 100, + }, + }, }, }, Updated: map[string]notifier.DiffUpdated{ "flag": { - Before: &flagv1.FlagData{ - Percentage: testconvert.Float64(100), - True: testconvert.Interface(true), - False: testconvert.Interface(true), - Default: testconvert.Interface(true), + Before: &flag.InternalFlag{ + Variations: &map[string]*interface{}{ + "Default": testconvert.Interface(true), + "True": testconvert.Interface(true), + "False": testconvert.Interface(true), + }, + DefaultRule: &flag.Rule{ + Name: testconvert.String("legacyDefaultRule"), + Percentages: &map[string]float64{ + "False": 0, + "True": 100, + }, + }, }, - After: &flagv1.FlagData{ - Percentage: testconvert.Float64(100), - True: testconvert.Interface(true), - False: testconvert.Interface(true), - Default: testconvert.Interface(false), + After: &flag.InternalFlag{ + Variations: &map[string]*interface{}{ + "Default": testconvert.Interface(false), + "True": testconvert.Interface(true), + "False": testconvert.Interface(true), + }, + DefaultRule: &flag.Rule{ + Name: testconvert.String("legacyDefaultRule"), + Percentages: &map[string]float64{ + "False": 0, + "True": 100, + }, + }, }, }, }, diff --git a/notifier/logsnotifier/notifier.go b/notifier/logsnotifier/notifier.go index 4d775a433b1..6a934229e46 100644 --- a/notifier/logsnotifier/notifier.go +++ b/notifier/logsnotifier/notifier.go @@ -30,11 +30,11 @@ func (c *Notifier) Notify(diff notifier.DiffCache, wg *sync.WaitGroup) error { fflog.Printf(c.Logger, "flag %v is turned OFF\n", key) continue } - fflog.Printf(c.Logger, "flag %v is turned ON (flag=[%v]) \n", key, flagDiff.After) + fflog.Printf(c.Logger, "flag %v is turned ON\n", key) continue } // key has changed in cache - fflog.Printf(c.Logger, "flag %s updated, old=[%v], new=[%v]\n", key, flagDiff.Before, flagDiff.After) + fflog.Printf(c.Logger, "flag %s updated\n", key) } return nil diff --git a/notifier/logsnotifier/notifier_test.go b/notifier/logsnotifier/notifier_test.go index 93d025c1bc7..ce3ca1d6e64 100644 --- a/notifier/logsnotifier/notifier_test.go +++ b/notifier/logsnotifier/notifier_test.go @@ -9,7 +9,6 @@ import ( "github.com/stretchr/testify/assert" "github.com/thomaspoignant/go-feature-flag/internal/flag" - flagv1 "github.com/thomaspoignant/go-feature-flag/internal/flagv1" "github.com/thomaspoignant/go-feature-flag/notifier" "github.com/thomaspoignant/go-feature-flag/testutils/testconvert" @@ -31,11 +30,19 @@ func TestLogNotifier_Notify(t *testing.T) { args: args{ diff: notifier.DiffCache{ Deleted: map[string]flag.Flag{ - "test-flag": &flagv1.FlagData{ - Percentage: testconvert.Float64(100), - True: testconvert.Interface(true), - False: testconvert.Interface(false), - Default: testconvert.Interface(false), + "test-flag": &flag.InternalFlag{ + Variations: &map[string]*interface{}{ + "Default": testconvert.Interface(false), + "False": testconvert.Interface(false), + "True": testconvert.Interface(true), + }, + DefaultRule: &flag.Rule{ + Name: testconvert.String("legacyDefaultRule"), + Percentages: &map[string]float64{ + "False": 0, + "True": 100, + }, + }, }, }, Updated: map[string]notifier.DiffUpdated{}, @@ -52,18 +59,40 @@ func TestLogNotifier_Notify(t *testing.T) { Deleted: map[string]flag.Flag{}, Updated: map[string]notifier.DiffUpdated{ "test-flag": { - Before: &flagv1.FlagData{ - Rule: testconvert.String("key eq \"random-key\""), - Percentage: testconvert.Float64(100), - True: testconvert.Interface(true), - False: testconvert.Interface(false), - Default: testconvert.Interface(false), + Before: &flag.InternalFlag{ + Rules: &[]flag.Rule{ + { + Name: testconvert.String("legacyRuleV0"), + Query: testconvert.String("key eq \"random-key\""), + Percentages: &map[string]float64{ + "False": 0, + "True": 100, + }, + }, + }, + Variations: &map[string]*interface{}{ + "Default": testconvert.Interface(false), + "False": testconvert.Interface(false), + "True": testconvert.Interface(true), + }, + DefaultRule: &flag.Rule{ + Name: testconvert.String("legacyDefaultRule"), + VariationResult: testconvert.String("Default"), + }, }, - After: &flagv1.FlagData{ - Percentage: testconvert.Float64(100), - True: testconvert.Interface(true), - False: testconvert.Interface(false), - Default: testconvert.Interface(false), + After: &flag.InternalFlag{ + Variations: &map[string]*interface{}{ + "Default": testconvert.Interface(false), + "False": testconvert.Interface(false), + "True": testconvert.Interface(true), + }, + DefaultRule: &flag.Rule{ + Name: testconvert.String("legacyDefaultRule"), + Percentages: &map[string]float64{ + "False": 0, + "True": 100, + }, + }, }, }, }, @@ -71,7 +100,7 @@ func TestLogNotifier_Notify(t *testing.T) { }, wg: &sync.WaitGroup{}, }, - expected: "^\\[" + testutils.RFC3339Regex + "\\] flag test-flag updated, old=\\[percentage=100%, rule=\"key eq \"random-key\"\", true=\"true\", false=\"false\", default=\"false\", disable=\"false\"\\], new=\\[percentage=100%, true=\"true\", false=\"false\", default=\"false\", disable=\"false\"\\]", + expected: "^\\[" + testutils.RFC3339Regex + "\\] flag test-flag updated", }, { name: "Disable flag", @@ -80,20 +109,48 @@ func TestLogNotifier_Notify(t *testing.T) { Deleted: map[string]flag.Flag{}, Updated: map[string]notifier.DiffUpdated{ "test-flag": { - Before: &flagv1.FlagData{ - Rule: testconvert.String("key eq \"random-key\""), - Percentage: testconvert.Float64(100), - True: testconvert.Interface(true), - False: testconvert.Interface(false), - Default: testconvert.Interface(false), + Before: &flag.InternalFlag{ + Rules: &[]flag.Rule{ + { + Name: testconvert.String("legacyRuleV0"), + Query: testconvert.String("key eq \"random-key\""), + Percentages: &map[string]float64{ + "False": 0, + "True": 100, + }, + }, + }, + Variations: &map[string]*interface{}{ + "Default": testconvert.Interface(false), + "False": testconvert.Interface(false), + "True": testconvert.Interface(true), + }, + DefaultRule: &flag.Rule{ + Name: testconvert.String("legacyDefaultRule"), + VariationResult: testconvert.String("Default"), + }, }, - After: &flagv1.FlagData{ - Rule: testconvert.String("key eq \"random-key\""), - Disable: testconvert.Bool(true), - Percentage: testconvert.Float64(100), - True: testconvert.Interface(true), - False: testconvert.Interface(false), - Default: testconvert.Interface(false), + After: &flag.InternalFlag{ + Rules: &[]flag.Rule{ + { + Name: testconvert.String("legacyRuleV0"), + Query: testconvert.String("key eq \"random-key\""), + Percentages: &map[string]float64{ + "False": 0, + "True": 100, + }, + }, + }, + Variations: &map[string]*interface{}{ + "Default": testconvert.Interface(false), + "False": testconvert.Interface(false), + "True": testconvert.Interface(true), + }, + DefaultRule: &flag.Rule{ + Name: testconvert.String("legacyDefaultRule"), + VariationResult: testconvert.String("Default"), + }, + Disable: testconvert.Bool(true), }, }, }, @@ -110,12 +167,26 @@ func TestLogNotifier_Notify(t *testing.T) { Deleted: map[string]flag.Flag{}, Updated: map[string]notifier.DiffUpdated{}, Added: map[string]flag.Flag{ - "add-test-flag": &flagv1.FlagData{ - Rule: testconvert.String("key eq \"random-key\""), - Percentage: testconvert.Float64(100), - True: testconvert.Interface(true), - False: testconvert.Interface(false), - Default: testconvert.Interface(false), + "add-test-flag": &flag.InternalFlag{ + Rules: &[]flag.Rule{ + { + Name: testconvert.String("legacyRuleV0"), + Query: testconvert.String("key eq \"random-key\""), + Percentages: &map[string]float64{ + "False": 0, + "True": 100, + }, + }, + }, + Variations: &map[string]*interface{}{ + "Default": testconvert.Interface(false), + "False": testconvert.Interface(false), + "True": testconvert.Interface(true), + }, + DefaultRule: &flag.Rule{ + Name: testconvert.String("legacyDefaultRule"), + VariationResult: testconvert.String("Default"), + }, }, }, }, @@ -130,20 +201,48 @@ func TestLogNotifier_Notify(t *testing.T) { Deleted: map[string]flag.Flag{}, Updated: map[string]notifier.DiffUpdated{ "test-flag": { - After: &flagv1.FlagData{ - Rule: testconvert.String("key eq \"random-key\""), - Percentage: testconvert.Float64(100), - True: testconvert.Interface(true), - False: testconvert.Interface(false), - Default: testconvert.Interface(false), + After: &flag.InternalFlag{ + Rules: &[]flag.Rule{ + { + Name: testconvert.String("legacyRuleV0"), + Query: testconvert.String("key eq \"random-key\""), + Percentages: &map[string]float64{ + "False": 0, + "True": 100, + }, + }, + }, + Variations: &map[string]*interface{}{ + "Default": testconvert.Interface(false), + "False": testconvert.Interface(false), + "True": testconvert.Interface(true), + }, + DefaultRule: &flag.Rule{ + Name: testconvert.String("legacyDefaultRule"), + VariationResult: testconvert.String("Default"), + }, }, - Before: &flagv1.FlagData{ - Rule: testconvert.String("key eq \"random-key\""), - Disable: testconvert.Bool(true), - Percentage: testconvert.Float64(100), - True: testconvert.Interface(true), - False: testconvert.Interface(false), - Default: testconvert.Interface(false), + Before: &flag.InternalFlag{ + Rules: &[]flag.Rule{ + { + Name: testconvert.String("legacyRuleV0"), + Query: testconvert.String("key eq \"random-key\""), + Percentages: &map[string]float64{ + "False": 0, + "True": 100, + }, + }, + }, + Variations: &map[string]*interface{}{ + "Default": testconvert.Interface(false), + "False": testconvert.Interface(false), + "True": testconvert.Interface(true), + }, + DefaultRule: &flag.Rule{ + Name: testconvert.String("legacyDefaultRule"), + VariationResult: testconvert.String("Default"), + }, + Disable: testconvert.Bool(true), }, }, }, @@ -151,7 +250,7 @@ func TestLogNotifier_Notify(t *testing.T) { }, wg: &sync.WaitGroup{}, }, - expected: "^\\[" + testutils.RFC3339Regex + "\\] flag test-flag is turned ON \\(flag=\\[percentage=100%, rule=\"key eq \"random-key\"\", true=\"true\", false=\"false\", default=\"false\", disable=\"false\"\\]\\)", + expected: "^\\[" + testutils.RFC3339Regex + "\\] flag test-flag is turned ON", }, } for _, tt := range tests { diff --git a/notifier/slacknotifier/notifier_test.go b/notifier/slacknotifier/notifier_test.go index d50f7638805..4b71eaf148a 100644 --- a/notifier/slacknotifier/notifier_test.go +++ b/notifier/slacknotifier/notifier_test.go @@ -11,7 +11,6 @@ import ( "github.com/stretchr/testify/assert" "github.com/thomaspoignant/go-feature-flag/internal/flag" - flagv1 "github.com/thomaspoignant/go-feature-flag/internal/flagv1" "github.com/thomaspoignant/go-feature-flag/notifier" "github.com/thomaspoignant/go-feature-flag/testutils" @@ -46,51 +45,99 @@ func TestSlackNotifier_Notify(t *testing.T) { statusCode: http.StatusOK, diff: notifier.DiffCache{ Added: map[string]flag.Flag{ - "test-flag3": &flagv1.FlagData{ - Percentage: testconvert.Float64(5), - True: testconvert.Interface("test"), - False: testconvert.Interface("false"), - Default: testconvert.Interface("default"), - Rule: testconvert.String("key eq \"random-key\""), + "test-flag3": &flag.InternalFlag{ + Rules: &[]flag.Rule{ + { + Name: testconvert.String("legacyRuleV0"), + Query: testconvert.String("key eq \"random-key\""), + Percentages: &map[string]float64{ + "False": 95, + "True": 5, + }, + }, + }, + Variations: &map[string]*interface{}{ + "Default": testconvert.Interface("default"), + "False": testconvert.Interface("false"), + "True": testconvert.Interface("test"), + }, + DefaultRule: &flag.Rule{ + Name: testconvert.String("legacyDefaultRule"), + VariationResult: testconvert.String("Default"), + }, TrackEvents: testconvert.Bool(true), Disable: testconvert.Bool(false), - Version: testconvert.Float64(1.1), + Version: testconvert.String("1.1"), }, }, Deleted: map[string]flag.Flag{ - "test-flag": &flagv1.FlagData{ - Rule: testconvert.String("key eq \"random-key\""), - Percentage: testconvert.Float64(100), - True: testconvert.Interface(true), - False: testconvert.Interface(false), - Default: testconvert.Interface(false), + "test-flag": &flag.InternalFlag{ + Rules: &[]flag.Rule{ + { + Name: testconvert.String("legacyRuleV0"), + Query: testconvert.String("key eq \"random-key\""), + Percentages: &map[string]float64{ + "False": 0, + "True": 100, + }, + }, + }, + Variations: &map[string]*interface{}{ + "Default": testconvert.Interface(false), + "False": testconvert.Interface(false), + "True": testconvert.Interface(true), + }, + DefaultRule: &flag.Rule{ + Name: testconvert.String("legacyDefaultRule"), + VariationResult: testconvert.String("Default"), + }, }, }, Updated: map[string]notifier.DiffUpdated{ "test-flag2": { - Before: &flagv1.FlagData{ - Percentage: testconvert.Float64(100), - True: testconvert.Interface(true), - False: testconvert.Interface(false), - Default: testconvert.Interface(false), - Disable: testconvert.Bool(false), - TrackEvents: testconvert.Bool(true), - Rollout: &flagv1.Rollout{ - Experimentation: &flagv1.Experimentation{ + Before: &flag.InternalFlag{ + Variations: &map[string]*interface{}{ + "Default": testconvert.Interface(false), + "False": testconvert.Interface(false), + "True": testconvert.Interface(true), + }, + DefaultRule: &flag.Rule{ + Name: testconvert.String("legacyDefaultRule"), + Percentages: &map[string]float64{ + "False": 0, + "True": 100, + }, + }, + Rollout: &flag.Rollout{ + Experimentation: &flag.ExperimentationRollout{ Start: testconvert.Time(time.Unix(1095379400, 0)), End: testconvert.Time(time.Unix(1095371000, 0)), }, }, }, - After: &flagv1.FlagData{ - Rule: testconvert.String("key eq \"not-a-ke\""), - Percentage: testconvert.Float64(80), - True: testconvert.Interface("strTrue"), - False: testconvert.Interface("strFalse"), - Default: testconvert.Interface("strDefault"), + After: &flag.InternalFlag{ + Variations: &map[string]*interface{}{ + "Default": testconvert.Interface("strDefault"), + "False": testconvert.Interface("strFalse"), + "True": testconvert.Interface("strTrue"), + }, + Rules: &[]flag.Rule{ + { + Name: testconvert.String("legacyRuleV0"), + Query: testconvert.String("key eq \"not-a-ke\""), + Percentages: &map[string]float64{ + "False": 20, + "True": 80, + }, + }, + }, + DefaultRule: &flag.Rule{ + Name: testconvert.String("legacyDefaultRule"), + VariationResult: testconvert.String("Default"), + }, Disable: testconvert.Bool(true), TrackEvents: testconvert.Bool(false), - Version: testconvert.Float64(1.1), + Version: testconvert.String("1.1"), }, }, }, diff --git a/notifier/slacknotifier/testdata/should_call_webhook_and_have_valid_results.json b/notifier/slacknotifier/testdata/should_call_webhook_and_have_valid_results.json index cfdacc8e2e1..d6efa482b3a 100644 --- a/notifier/slacknotifier/testdata/should_call_webhook_and_have_valid_results.json +++ b/notifier/slacknotifier/testdata/should_call_webhook_and_have_valid_results.json @@ -14,48 +14,53 @@ "title": "✏️ Flag \"test-flag2\" updated", "fields": [ { - "title": "Rule", - "value": "nil =\u003e (*string)(\"key eq \\\"not-a-ke\\\"\")", - "short": false + "title": "Variations.Default", + "value": "false =\u003e \"strDefault\"", + "short": true }, { - "title": "Percentage", - "value": "100 =\u003e 80", + "title": "Variations.False", + "value": "false =\u003e \"strFalse\"", "short": true }, { - "title": "True", + "title": "Variations.True", "value": "true =\u003e \"strTrue\"", "short": true }, { - "title": "False", - "value": "false =\u003e \"strFalse\"", - "short": true + "title": "Rules", + "value": "nil =\u003e (*[]flag.Rule){flag.Rule{Name:(*string)(\"legacyRuleV0\"), Query:(*string)(\"key eq \\\"not-a-ke\\\"\"), VariationResult:(*string)(nil), Percentages:(*map[string]float64){\"False\":20, \"True\":80}, ProgressiveRollout:(*flag.ProgressiveRollout)(nil)}}", + "short": false }, { - "title": "Default", - "value": "false =\u003e \"strDefault\"", + "title": "DefaultRule.VariationResult", + "value": "nil =\u003e (*string)(\"Default\")", "short": true }, + { + "title": "DefaultRule.Percentages", + "value": "(*map[string]float64){\"False\":0, \"True\":100} =\u003e nil", + "short": false + }, + { + "title": "Rollout", + "value": "(*flag.Rollout){Experimentation:(*flag.ExperimentationRollout){Start:(*time.Time){wall:0, ext:63230976200, loc:(*time.Location){name:\"\", zone:[]time.zone(nil), tx:[]time.zoneTrans(nil), extend:\"\", cacheStart:0, cacheEnd:0, cacheZone:(*time.zone)(nil)}}, End:(*time.Time){wall:0, ext:63230967800, loc:(*time.Location){name:\"\", zone:[]time.zone(nil), tx:[]time.zoneTrans(nil), extend:\"\", cacheStart:0, cacheEnd:0, cacheZone:(*time.zone)(nil)}}}, Scheduled:(*[]flag.ScheduledStep)(nil)} =\u003e nil", + "short": false + }, { "title": "TrackEvents", - "value": "true =\u003e false", + "value": "nil =\u003e (*bool)(false)", "short": true }, { "title": "Disable", - "value": "false =\u003e true", + "value": "nil =\u003e (*bool)(true)", "short": true }, - { - "title": "Rollout", - "value": "(*flagv1.Rollout){Experimentation:(*flagv1.Experimentation){Start:(*time.Time){wall:0, ext:63230976200, loc:(*time.Location){name:\"\", zone:[]time.zone(nil), tx:[]time.zoneTrans(nil), extend:\"\", cacheStart:0, cacheEnd:0, cacheZone:(*time.zone)(nil)}}, End:(*time.Time){wall:0, ext:63230967800, loc:(*time.Location){name:\"\", zone:[]time.zone(nil), tx:[]time.zoneTrans(nil), extend:\"\", cacheStart:0, cacheEnd:0, cacheZone:(*time.zone)(nil)}}}, Progressive:(*flagv1.Progressive)(nil), Scheduled:(*flagv1.ScheduledRollout)(nil)} =\u003e nil", - "short": false - }, { "title": "Version", - "value": "nil =\u003e (*float64)(1.1)", + "value": "nil =\u003e (*string)(\"1.1\")", "short": true } ], From 5e158d279d47ec415445a217f4d591bc3bf94f5e Mon Sep 17 00:00:00 2001 From: Thomas Poignant Date: Fri, 29 Jul 2022 18:59:33 +0200 Subject: [PATCH 11/50] Remove usage of flagv1 package Signed-off-by: Thomas Poignant --- internal/dto/converter_v0.go | 7 +- internal/dto/dto.go | 33 +---- internal/dto/rollout_v0.go | 72 +++++++++ internal/toremove/toremove.go | 9 +- notifier/webhooknotifier/notifier_test.go | 139 +++++++++++++----- ...d_call_webhook_and_have_valid_results.json | 95 +++++++++--- .../should_not_be_signed_if_no_secret.json | 22 ++- 7 files changed, 272 insertions(+), 105 deletions(-) create mode 100644 internal/dto/rollout_v0.go diff --git a/internal/dto/converter_v0.go b/internal/dto/converter_v0.go index ab89423a7f7..638b920ab0c 100644 --- a/internal/dto/converter_v0.go +++ b/internal/dto/converter_v0.go @@ -2,7 +2,6 @@ package dto import ( "github.com/thomaspoignant/go-feature-flag/internal/flag" - "github.com/thomaspoignant/go-feature-flag/internal/flagv1" ) var ( @@ -16,10 +15,10 @@ var ( defaultVariation = "Default" ) -// ConvertV0DtoToFlag is converting a flag in the config file to the internal format. +// ConvertV0DtoToInternalFlag is converting a flag in the config file to the internal format. // this function convert only the old format of the flag (before v1.0.0), to keep // backward support of the configurations. -func ConvertV0DtoToFlag(d DTO, isScheduleStep bool) flag.InternalFlag { +func ConvertV0DtoToInternalFlag(d DTO, isScheduleStep bool) flag.InternalFlag { // Create variations based on the available definition in the flag v0 var variations *map[string]*interface{} newVariations := createVariationsV0(d, isScheduleStep) @@ -125,7 +124,7 @@ func createVariationsV0(d DTO, isScheduleStep bool) map[string]*interface{} { return variations } -func convertRollout(rollout flagv1.Rollout) *flag.Rollout { +func convertRollout(rollout RolloutV0) *flag.Rollout { r := flag.Rollout{} if rollout.Experimentation != nil && rollout.Experimentation.Start != nil && rollout.Experimentation.End != nil { r.Experimentation = &flag.ExperimentationRollout{ diff --git a/internal/dto/dto.go b/internal/dto/dto.go index 55771499f32..dc8c6730983 100644 --- a/internal/dto/dto.go +++ b/internal/dto/dto.go @@ -1,10 +1,7 @@ package dto import ( - "strconv" - "github.com/thomaspoignant/go-feature-flag/internal/flag" - "github.com/thomaspoignant/go-feature-flag/internal/flagv1" ) // DTO is representing all the fields we can have in a flag. @@ -47,7 +44,7 @@ type DTOv0 struct { // Rollout is the object to configure how the flag is rolled out. // You have different rollout strategy available but only one is used at a time. - Rollout *flagv1.Rollout `json:"rollout,omitempty" yaml:"rollout,omitempty" toml:"rollout,omitempty"` + Rollout *RolloutV0 `json:"rollout,omitempty" yaml:"rollout,omitempty" toml:"rollout,omitempty"` // Version (optional) This field contains the version of the flag. // The version is manually managed when you configure your flags and it is used to display the information @@ -55,32 +52,6 @@ type DTOv0 struct { Version *string `json:"version,omitempty" yaml:"version,omitempty" toml:"version,omitempty"` } -func (d *DTO) ConvertLegacy() flagv1.FlagData { - version, _ := strconv.ParseFloat(*d.Version, 32) - return flagv1.FlagData{ - Rule: d.Rule, - Percentage: d.Percentage, - True: d.True, - False: d.False, - Default: d.Default, - TrackEvents: d.TrackEvents, - Disable: d.Disable, - Rollout: d.Rollout, - Version: &version, - } -} - func (d *DTO) Convert() flag.InternalFlag { - return ConvertV0DtoToFlag(*d, false) - // return flagv1.FlagData{ - // Rule: d.Rule, - // Percentage: d.Percentage, - // True: d.True, - // False: d.False, - // Default: d.Default, - // TrackEvents: d.TrackEvents, - // Disable: d.Disable, - // Rollout: d.Rollout, - // Version: d.Version, - //} + return ConvertV0DtoToInternalFlag(*d, false) } diff --git a/internal/dto/rollout_v0.go b/internal/dto/rollout_v0.go new file mode 100644 index 00000000000..c35370e80cc --- /dev/null +++ b/internal/dto/rollout_v0.go @@ -0,0 +1,72 @@ +package dto + +import "time" + +type RolloutV0 struct { + // Experimentation is your struct to configure an experimentation, it will allow you to configure a start date and + // an end date for your flag. + // When the experimentation is not running, the flag will serve the default value. + Experimentation *ExperimentationV0 `json:"experimentation,omitempty" yaml:"experimentation,omitempty" toml:"experimentation,omitempty"` // nolint: lll + + // Progressive is your struct to configure a progressive rollout deployment of your flag. + // It will allow you to ramp up the percentage of your flag over time. + // You can decide at which percentage you starts and at what percentage you ends in your release ramp. + // Before the start date we will serve the initial percentage and after we will serve the end percentage. + Progressive *ProgressiveV0 `json:"progressive,omitempty" yaml:"progressive,omitempty" toml:"progressive,omitempty"` // nolint: lll + + // Scheduled is your struct to configure an update on some fields of your flag over time. + // You can add several steps that updates the flag, this is typically used if you want to gradually add more user + // in your flag. + Scheduled *ScheduledRolloutV0 `json:"scheduled,omitempty" yaml:"scheduled,omitempty" toml:"scheduled,omitempty"` // nolint: lll +} + +type ExperimentationV0 struct { + // Start is the starting time of the experimentation + Start *time.Time `json:"start,omitempty" yaml:"start,omitempty" toml:"start,omitempty"` + + // End is the ending time of the experimentation + End *time.Time `json:"end,omitempty" yaml:"end,omitempty" toml:"end,omitempty"` +} + +// ProgressiveV0 is the configuration struct to define a progressive rollout. +type ProgressiveV0 struct { + // Percentage is where you can configure at what percentage your progressive rollout start + // and at what percentage it ends. + // This field is optional + Percentage ProgressivePercentageV0 `json:"percentage,omitempty" yaml:"percentage,omitempty" toml:"percentage,omitempty"` + + // ReleaseRamp is the defining when the progressive rollout starts and ends. + // This field is mandatory if you want to use a progressive rollout. + // If any field missing we ignore the progressive rollout. + ReleaseRamp ProgressiveReleaseRampV0 `json:"releaseRamp,omitempty" yaml:"releaseRamp,omitempty" toml:"releaseRamp,omitempty"` // nolint: lll +} + +type ProgressivePercentageV0 struct { + // Initial is the initial percentage before the rollout start date. + // This field is optional + // Default: 0.0 + Initial float64 `json:"initial,omitempty" yaml:"initial,omitempty" toml:"initial,omitempty"` + + // End is the target percentage we want to reach at the end of the rollout phase. + // This field is optional + // Default: 100.0 + End float64 `json:"end,omitempty" yaml:"end,omitempty" toml:"end,omitempty"` +} + +type ProgressiveReleaseRampV0 struct { + // Start is the starting time of the ramp + Start *time.Time `json:"start,omitempty" yaml:"start,omitempty" toml:"start,omitempty"` + + // End is the ending time of the ramp + End *time.Time `json:"end,omitempty" yaml:"end,omitempty" toml:"end,omitempty"` +} + +type ScheduledRolloutV0 struct { + // Steps is the list of updates to do in a specific date. + Steps []ScheduledStepV0 `json:"steps,omitempty" yaml:"steps,omitempty" toml:"steps,omitempty"` +} + +type ScheduledStepV0 struct { + DTOv0 `yaml:",inline"` + Date *time.Time `json:"date,omitempty" yaml:"date,omitempty" toml:"date,omitempty"` +} diff --git a/internal/toremove/toremove.go b/internal/toremove/toremove.go index 8dccd189fab..64d14a4346f 100644 --- a/internal/toremove/toremove.go +++ b/internal/toremove/toremove.go @@ -2,6 +2,7 @@ package main import ( "fmt" + "github.com/thomaspoignant/go-feature-flag/internal/dto" "github.com/thomaspoignant/go-feature-flag/testutils/testconvert" "gopkg.in/yaml.v2" @@ -11,10 +12,10 @@ func main() { t := map[string]dto.DTO{ "test-flag": { DTOv0: dto.DTOv0{ - Percentage: testconvert.Float64(100), - True: testconvert.Interface(true), - False: testconvert.Interface(false), - Default: testconvert.Interface(false), + Percentage: testconvert.Float64(5), + True: testconvert.Interface("test"), + False: testconvert.Interface("false"), + Default: testconvert.Interface("default"), }, }, } diff --git a/notifier/webhooknotifier/notifier_test.go b/notifier/webhooknotifier/notifier_test.go index 0155208e42d..378a23e019e 100644 --- a/notifier/webhooknotifier/notifier_test.go +++ b/notifier/webhooknotifier/notifier_test.go @@ -2,6 +2,7 @@ package webhooknotifier import ( "encoding/json" + "fmt" "io/ioutil" "net/http" "sync" @@ -9,7 +10,6 @@ import ( "github.com/stretchr/testify/assert" "github.com/thomaspoignant/go-feature-flag/internal/flag" - flagv1 "github.com/thomaspoignant/go-feature-flag/internal/flagv1" "github.com/thomaspoignant/go-feature-flag/notifier" "github.com/thomaspoignant/go-feature-flag/testutils/testconvert" @@ -45,45 +45,95 @@ func Test_webhookNotifier_Notify(t *testing.T) { }, expected: expected{ bodyPath: "./testdata/should_call_webhook_and_have_valid_results.json", - signature: "sha256=23effe4da9927ab72df5202a3146e6be39c12b7f6cee99f8d2e19326d8806b81", + signature: "sha256=366472030e941aa3a8ebe0e715552261f714992dec10f857da23f7e6d39c7e1d", }, args: args{ url: "http://webhook.example/hook", statusCode: http.StatusOK, diff: notifier.DiffCache{ Added: map[string]flag.Flag{ - "test-flag3": &flagv1.FlagData{ - Percentage: testconvert.Float64(5), - True: testconvert.Interface("test"), - False: testconvert.Interface("false"), - Default: testconvert.Interface("default"), + "test-flag3": &flag.InternalFlag{ + Variations: &map[string]*interface{}{ + "Default": testconvert.Interface("default"), + "False": testconvert.Interface("false"), + "True": testconvert.Interface("test"), + }, + DefaultRule: &flag.Rule{ + Name: testconvert.String("legacyDefaultRule"), + Percentages: &map[string]float64{ + "False": 95, + "True": 5, + }, + }, }, }, Deleted: map[string]flag.Flag{ - "test-flag": &flagv1.FlagData{ - Rule: testconvert.String("key eq \"random-key\""), - Percentage: testconvert.Float64(100), - True: testconvert.Interface(true), - False: testconvert.Interface(false), - Default: testconvert.Interface(false), + "test-flag": &flag.InternalFlag{ + Rules: &[]flag.Rule{ + { + Name: testconvert.String("legacyRuleV0"), + Query: testconvert.String("key eq \"random-key\""), + Percentages: &map[string]float64{ + "False": 0, + "True": 100, + }, + }, + }, + Variations: &map[string]*interface{}{ + "Default": testconvert.Interface(false), + "False": testconvert.Interface(false), + "True": testconvert.Interface(true), + }, + DefaultRule: &flag.Rule{ + Name: testconvert.String("legacyDefaultRule"), + VariationResult: testconvert.String("Default"), + }, }, }, Updated: map[string]notifier.DiffUpdated{ "test-flag2": { - Before: &flagv1.FlagData{ - Rule: testconvert.String("key eq \"not-a-key\""), - Percentage: testconvert.Float64(100), - True: testconvert.Interface(true), - False: testconvert.Interface(false), - Default: testconvert.Interface(false), + Before: &flag.InternalFlag{ + Rules: &[]flag.Rule{ + { + Name: testconvert.String("legacyRuleV0"), + Query: testconvert.String("key eq \"not-a-key\""), + Percentages: &map[string]float64{ + "False": 0, + "True": 100, + }, + }, + }, + Variations: &map[string]*interface{}{ + "Default": testconvert.Interface(false), + "False": testconvert.Interface(false), + "True": testconvert.Interface(true), + }, + DefaultRule: &flag.Rule{ + Name: testconvert.String("legacyDefaultRule"), + VariationResult: testconvert.String("Default"), + }, }, - After: &flagv1.FlagData{ - Rule: testconvert.String("key eq \"not-a-key\""), - Percentage: testconvert.Float64(100), - True: testconvert.Interface(true), - False: testconvert.Interface(false), - Default: testconvert.Interface(false), - Disable: testconvert.Bool(true), + After: &flag.InternalFlag{ + Rules: &[]flag.Rule{ + { + Name: testconvert.String("legacyRuleV0"), + Query: testconvert.String("key eq \"not-a-key\""), + Percentages: &map[string]float64{ + "False": 0, + "True": 100, + }, + }, + }, + Variations: &map[string]*interface{}{ + "Default": testconvert.Interface(false), + "False": testconvert.Interface(false), + "True": testconvert.Interface(true), + }, + DefaultRule: &flag.Rule{ + Name: testconvert.String("legacyDefaultRule"), + VariationResult: testconvert.String("Default"), + }, + Disable: testconvert.Bool(true), }, }, }, @@ -101,11 +151,19 @@ func Test_webhookNotifier_Notify(t *testing.T) { statusCode: http.StatusOK, diff: notifier.DiffCache{ Added: map[string]flag.Flag{ - "test-flag3": &flagv1.FlagData{ - Percentage: testconvert.Float64(5), - True: testconvert.Interface("test"), - False: testconvert.Interface("false"), - Default: testconvert.Interface("default"), + "test-flag3": &flag.InternalFlag{ + Variations: &map[string]*interface{}{ + "Default": testconvert.Interface("default"), + "False": testconvert.Interface("false"), + "True": testconvert.Interface("test"), + }, + DefaultRule: &flag.Rule{ + Name: testconvert.String("legacyDefaultRule"), + Percentages: &map[string]float64{ + "False": 95, + "True": 5, + }, + }, }, }, Deleted: map[string]flag.Flag{}, @@ -173,6 +231,7 @@ func Test_webhookNotifier_Notify(t *testing.T) { } else { assert.NoError(t, err) content, _ := ioutil.ReadFile(tt.expected.bodyPath) + fmt.Println(mockHTTPClient.Body) assert.JSONEq(t, string(content), mockHTTPClient.Body) assert.Equal(t, tt.expected.signature, mockHTTPClient.Signature) } @@ -184,11 +243,19 @@ func Test_webhookNotifier_no_meta_data(t *testing.T) { mockHTTPClient := &testutils.HTTPClientMock{StatusCode: 200, ForceError: false} diff := notifier.DiffCache{ Added: map[string]flag.Flag{ - "test-flag3": &flagv1.FlagData{ - Percentage: testconvert.Float64(5), - True: testconvert.Interface("test"), - False: testconvert.Interface("false"), - Default: testconvert.Interface("default"), + "test-flag3": &flag.InternalFlag{ + Variations: &map[string]*interface{}{ + "Default": testconvert.Interface("default"), + "False": testconvert.Interface("false"), + "True": testconvert.Interface("test"), + }, + DefaultRule: &flag.Rule{ + Name: testconvert.String("legacyDefaultRule"), + Percentages: &map[string]float64{ + "False": 95, + "True": 5, + }, + }, }, }, Deleted: map[string]flag.Flag{}, diff --git a/notifier/webhooknotifier/testdata/should_call_webhook_and_have_valid_results.json b/notifier/webhooknotifier/testdata/should_call_webhook_and_have_valid_results.json index fc8f305525a..b92732c1182 100644 --- a/notifier/webhooknotifier/testdata/should_call_webhook_and_have_valid_results.json +++ b/notifier/webhooknotifier/testdata/should_call_webhook_and_have_valid_results.json @@ -1,44 +1,93 @@ { + "meta": { + "hostname": "toto" + }, "flags": { "deleted": { "test-flag": { - "rule": "key eq \"random-key\"", - "percentage": 100, - "true": true, - "false": false, - "default": false + "variations": { + "Default": false, + "False": false, + "True": true + }, + "targeting": [ + { + "name": "legacyRuleV0", + "query": "key eq \"random-key\"", + "percentage": { + "False": 0, + "True": 100 + } + } + ], + "defaultRule": { + "name": "legacyDefaultRule", + "variation": "Default" + } } }, "added": { "test-flag3": { - "percentage": 5, - "true": "test", - "false": "false", - "default": "default" + "variations": { + "Default": "default", + "False": "false", + "True": "test" + }, + "defaultRule": { + "name": "legacyDefaultRule", + "percentage": { + "False": 95, + "True": 5 + } + } } }, "updated": { "test-flag2": { "old_value": { - "rule": "key eq \"not-a-key\"", - "percentage": 100, - "true": true, - "false": false, - "default": false + "variations": { + "Default": false, + "False": false, + "True": true + }, + "targeting": [ + { + "name": "legacyRuleV0", + "query": "key eq \"not-a-key\"", + "percentage": { + "False": 0, + "True": 100 + } + } + ], + "defaultRule": { + "name": "legacyDefaultRule", + "variation": "Default" + } }, "new_value": { - "disable": true, - "rule": "key eq \"not-a-key\"", - "percentage": 100, - "true": true, - "false": false, - "default": false, + "variations": { + "Default": false, + "False": false, + "True": true + }, + "targeting": [ + { + "name": "legacyRuleV0", + "query": "key eq \"not-a-key\"", + "percentage": { + "False": 0, + "True": 100 + } + } + ], + "defaultRule": { + "name": "legacyDefaultRule", + "variation": "Default" + }, "disable": true } } } - }, - "meta": { - "hostname": "toto" } } diff --git a/notifier/webhooknotifier/testdata/should_not_be_signed_if_no_secret.json b/notifier/webhooknotifier/testdata/should_not_be_signed_if_no_secret.json index ec20d2cb32a..690a4d87ab9 100644 --- a/notifier/webhooknotifier/testdata/should_not_be_signed_if_no_secret.json +++ b/notifier/webhooknotifier/testdata/should_not_be_signed_if_no_secret.json @@ -1,17 +1,25 @@ { + "meta": { + "hostname": "toto" + }, "flags": { "deleted": {}, "added": { "test-flag3": { - "percentage": 5, - "true": "test", - "false": "false", - "default": "default" + "variations": { + "Default": "default", + "False": "false", + "True": "test" + }, + "defaultRule": { + "name": "legacyDefaultRule", + "percentage": { + "False": 95, + "True": 5 + } + } } }, "updated": {} - }, - "meta": { - "hostname": "toto" } } From 386c29915664e78fd095432d1d5a57ed0f9dae51 Mon Sep 17 00:00:00 2001 From: Thomas Poignant Date: Fri, 29 Jul 2022 19:17:40 +0200 Subject: [PATCH 12/50] Order for constitency Signed-off-by: Thomas Poignant --- internal/dto/converter_v0.go | 18 ++++++++ notifier/slacknotifier/notifier.go | 10 +++++ ...d_call_webhook_and_have_valid_results.json | 42 +++++++++---------- 3 files changed, 49 insertions(+), 21 deletions(-) diff --git a/internal/dto/converter_v0.go b/internal/dto/converter_v0.go index 638b920ab0c..551cd7a3896 100644 --- a/internal/dto/converter_v0.go +++ b/internal/dto/converter_v0.go @@ -132,6 +132,24 @@ func convertRollout(rollout RolloutV0) *flag.Rollout { End: rollout.Experimentation.End, } } + + if rollout.Scheduled != nil && rollout.Scheduled.Steps != nil { + var convertedSteps []flag.ScheduledStep + for _, v := range rollout.Scheduled.Steps { + converter := "v0" + toConvert := DTO{ + DTOv0: v.DTOv0, + Converter: &converter, + } + step := flag.ScheduledStep{ + InternalFlag: ConvertV0DtoToInternalFlag(toConvert, true), + Date: v.Date, + } + convertedSteps = append(convertedSteps, step) + } + r.Scheduled = &convertedSteps + } + return &r } diff --git a/notifier/slacknotifier/notifier.go b/notifier/slacknotifier/notifier.go index 7ff40018f25..448ca46d170 100644 --- a/notifier/slacknotifier/notifier.go +++ b/notifier/slacknotifier/notifier.go @@ -8,6 +8,7 @@ import ( "net/http" "net/url" "os" + "sort" "strings" "sync" @@ -132,6 +133,9 @@ func convertUpdatedFlagsToSlackMessage(diffCache notifier.DiffCache) []attachmen ) } } + + sort.Sort(ByTitle(attachment.Fields)) + attachments = append(attachments, attachment) } return attachments @@ -170,3 +174,9 @@ type Field struct { Value string `json:"value"` Short bool `json:"short"` } + +type ByTitle []Field + +func (a ByTitle) Len() int { return len(a) } +func (a ByTitle) Less(i, j int) bool { return a[i].Title < a[j].Title } +func (a ByTitle) Swap(i, j int) { a[i], a[j] = a[j], a[i] } diff --git a/notifier/slacknotifier/testdata/should_call_webhook_and_have_valid_results.json b/notifier/slacknotifier/testdata/should_call_webhook_and_have_valid_results.json index d6efa482b3a..acc131482dd 100644 --- a/notifier/slacknotifier/testdata/should_call_webhook_and_have_valid_results.json +++ b/notifier/slacknotifier/testdata/should_call_webhook_and_have_valid_results.json @@ -14,48 +14,48 @@ "title": "✏️ Flag \"test-flag2\" updated", "fields": [ { - "title": "Variations.Default", - "value": "false =\u003e \"strDefault\"", - "short": true + "title": "DefaultRule.Percentages", + "value": "(*map[string]float64){\"False\":0, \"True\":100} =\u003e nil", + "short": false }, { - "title": "Variations.False", - "value": "false =\u003e \"strFalse\"", + "title": "DefaultRule.VariationResult", + "value": "nil =\u003e (*string)(\"Default\")", "short": true }, { - "title": "Variations.True", - "value": "true =\u003e \"strTrue\"", + "title": "Disable", + "value": "nil =\u003e (*bool)(true)", "short": true }, + { + "title": "Rollout", + "value": "(*flag.Rollout){Experimentation:(*flag.ExperimentationRollout){Start:(*time.Time){wall:0, ext:63230976200, loc:(*time.Location){name:\"\", zone:[]time.zone(nil), tx:[]time.zoneTrans(nil), extend:\"\", cacheStart:0, cacheEnd:0, cacheZone:(*time.zone)(nil)}}, End:(*time.Time){wall:0, ext:63230967800, loc:(*time.Location){name:\"\", zone:[]time.zone(nil), tx:[]time.zoneTrans(nil), extend:\"\", cacheStart:0, cacheEnd:0, cacheZone:(*time.zone)(nil)}}}, Scheduled:(*[]flag.ScheduledStep)(nil)} =\u003e nil", + "short": false + }, { "title": "Rules", "value": "nil =\u003e (*[]flag.Rule){flag.Rule{Name:(*string)(\"legacyRuleV0\"), Query:(*string)(\"key eq \\\"not-a-ke\\\"\"), VariationResult:(*string)(nil), Percentages:(*map[string]float64){\"False\":20, \"True\":80}, ProgressiveRollout:(*flag.ProgressiveRollout)(nil)}}", "short": false }, { - "title": "DefaultRule.VariationResult", - "value": "nil =\u003e (*string)(\"Default\")", + "title": "TrackEvents", + "value": "nil =\u003e (*bool)(false)", "short": true }, { - "title": "DefaultRule.Percentages", - "value": "(*map[string]float64){\"False\":0, \"True\":100} =\u003e nil", - "short": false - }, - { - "title": "Rollout", - "value": "(*flag.Rollout){Experimentation:(*flag.ExperimentationRollout){Start:(*time.Time){wall:0, ext:63230976200, loc:(*time.Location){name:\"\", zone:[]time.zone(nil), tx:[]time.zoneTrans(nil), extend:\"\", cacheStart:0, cacheEnd:0, cacheZone:(*time.zone)(nil)}}, End:(*time.Time){wall:0, ext:63230967800, loc:(*time.Location){name:\"\", zone:[]time.zone(nil), tx:[]time.zoneTrans(nil), extend:\"\", cacheStart:0, cacheEnd:0, cacheZone:(*time.zone)(nil)}}}, Scheduled:(*[]flag.ScheduledStep)(nil)} =\u003e nil", - "short": false + "title": "Variations.Default", + "value": "false =\u003e \"strDefault\"", + "short": true }, { - "title": "TrackEvents", - "value": "nil =\u003e (*bool)(false)", + "title": "Variations.False", + "value": "false =\u003e \"strFalse\"", "short": true }, { - "title": "Disable", - "value": "nil =\u003e (*bool)(true)", + "title": "Variations.True", + "value": "true =\u003e \"strTrue\"", "short": true }, { From 6a46813a2373438ebaaaa6e0f66e2d6bcb259d15 Mon Sep 17 00:00:00 2001 From: Thomas Poignant Date: Mon, 1 Aug 2022 10:58:31 +0200 Subject: [PATCH 13/50] Remove flagv1 package Signed-off-by: Thomas Poignant --- internal/flagv1/flag_data.go | 386 ---------------- internal/flagv1/flag_priv_test.go | 449 ------------------ internal/flagv1/flag_pub_test.go | 725 ------------------------------ internal/flagv1/rollout.go | 97 ---- internal/flagv1/rollout_test.go | 86 ---- internal/flagv1/variation_type.go | 12 - 6 files changed, 1755 deletions(-) delete mode 100644 internal/flagv1/flag_data.go delete mode 100644 internal/flagv1/flag_priv_test.go delete mode 100644 internal/flagv1/flag_pub_test.go delete mode 100644 internal/flagv1/rollout.go delete mode 100644 internal/flagv1/rollout_test.go delete mode 100644 internal/flagv1/variation_type.go diff --git a/internal/flagv1/flag_data.go b/internal/flagv1/flag_data.go deleted file mode 100644 index 117e7515d7d..00000000000 --- a/internal/flagv1/flag_data.go +++ /dev/null @@ -1,386 +0,0 @@ -package flagv1 - -import ( - "fmt" - "math" - "strconv" - "strings" - "time" - - "github.com/thomaspoignant/go-feature-flag/internal/flag" - - "github.com/nikunjy/rules/parser" - "github.com/thomaspoignant/go-feature-flag/ffuser" - "github.com/thomaspoignant/go-feature-flag/internal/utils" -) - -// percentageMultiplier is the multiplier used to have a bigger range of possibility. -const percentageMultiplier = float64(1000) - -// FlagData describe the fields of a flag. -type FlagData struct { - // Rule is the query use to select on which user the flag should apply. - // Rule format is based on the nikunjy/rules module. - // If no rule set, the flag apply to all users (percentage still apply). - Rule *string `json:"rule,omitempty" yaml:"rule,omitempty" toml:"rule,omitempty"` - - // Percentage of the users affected by the flag. - // Default value is 0 - Percentage *float64 `json:"percentage,omitempty" yaml:"percentage,omitempty" toml:"percentage,omitempty"` - - // True is the value return by the flag if apply to the user (rule is evaluated to true) - // and user is in the active percentage. - True *interface{} `json:"true,omitempty" yaml:"true,omitempty" toml:"true,omitempty"` - - // False is the value return by the flag if apply to the user (rule is evaluated to true) - // and user is not in the active percentage. - False *interface{} `json:"false,omitempty" yaml:"false,omitempty" toml:"false,omitempty"` - - // Default is the value return by the flag if not apply to the user (rule is evaluated to false). - Default *interface{} `json:"default,omitempty" yaml:"default,omitempty" toml:"default,omitempty"` - - // TrackEvents is false if you don't want to export the data in your data exporter. - // Default value is true - TrackEvents *bool `json:"trackEvents,omitempty" yaml:"trackEvents,omitempty" toml:"trackEvents,omitempty"` - - // Disable is true if the flag is disabled. - Disable *bool `json:"disable,omitempty" yaml:"disable,omitempty" toml:"disable,omitempty"` - - // Rollout is the object to configure how the flag is rollout. - // You have different rollout strategy available but only one is used at a time. - Rollout *Rollout `json:"rollout,omitempty" yaml:"rollout,omitempty" toml:"rollout,omitempty"` - - // Version (optional) This field contains the version of the flag. - // The version is manually managed when you configure your flags and it is used to display the information - // in the notifications and data collection. - Version *float64 `json:"version,omitempty" yaml:"version,omitempty" toml:"version,omitempty"` -} - -// Value is returning the Value associate to the flag (True / False / Default ) based -// if the toggle apply to the user or not. -func (f *FlagData) Value( - flagName string, - user ffuser.User, - evaluationCtx flag.EvaluationContext, -) (interface{}, flag.ResolutionDetails) { - f.updateFlagStage() - if f.isExperimentationOver() { - // if we have an experimentation that has not started or that is finished we use the default value. - return f.getDefault(), flag.ResolutionDetails{ - Variant: VariationDefault, - Reason: flag.ReasonDefault, - } - } - - // Flag disable we cannot apply it. - if f.IsDisable() { - return evaluationCtx.DefaultSdkValue, flag.ResolutionDetails{ - Variant: flag.VariationSDKDefault, - Reason: flag.ReasonDisabled, - } - } - - // we are targeting all users - if f.getRule() == "" && f.getPercentage() == 100 { - return f.getTrue(), flag.ResolutionDetails{ - Variant: VariationTrue, - Reason: flag.ReasonTargetingMatch, - } - } - - if f.evaluateRule(user, evaluationCtx.Environment) { - if f.isInPercentage(flagName, user) { - // Rule applied and user in the cohort. - return f.getTrue(), flag.ResolutionDetails{ - Variant: VariationTrue, - Reason: flag.ReasonSplit, - } - } - // Rule applied and user not in the cohort. - return f.getFalse(), flag.ResolutionDetails{ - Variant: VariationFalse, - Reason: flag.ReasonSplit, - } - } - - // Default value is used if the rule does not apply to the user. - return f.getDefault(), flag.ResolutionDetails{ - Variant: VariationDefault, - Reason: flag.ReasonDefault, - } -} - -func (f *FlagData) isExperimentationOver() bool { - now := time.Now() - return f.Rollout != nil && f.Rollout.Experimentation != nil && - ((f.Rollout.Experimentation.Start != nil && now.Before(*f.Rollout.Experimentation.Start)) || - (f.Rollout.Experimentation.End != nil && now.After(*f.Rollout.Experimentation.End))) -} - -// isInPercentage check if the user is in the cohort for the toggle. -func (f *FlagData) isInPercentage(flagName string, user ffuser.User) bool { - percentage := int32(f.getActualPercentage()) - maxPercentage := uint32(100 * percentageMultiplier) - - // <= 0% - if percentage <= 0 { - return false - } - // >= 100% - if uint32(percentage) >= maxPercentage { - return true - } - - hashID := utils.Hash(flagName+user.GetKey()) % maxPercentage - return hashID < uint32(percentage) -} - -// evaluateRule is checking if the rule can apply to a specific user. -func (f *FlagData) evaluateRule(user ffuser.User, environment string) bool { - // No rule means that all user can be impacted. - if f.getRule() == "" { - return true - } - - // Evaluate the rule on the user. - userMap := utils.UserToMap(user) - if environment != "" { - userMap["env"] = environment - } - return parser.Evaluate(f.getRule(), userMap) -} - -// string display correctly a flag -func (f FlagData) String() string { - toString := []string{} - toString = append(toString, fmt.Sprintf("percentage=%d%%", int64(math.Round(f.getPercentage())))) - if f.getRule() != "" { - toString = append(toString, fmt.Sprintf("rule=\"%s\"", f.getRule())) - } - toString = append(toString, fmt.Sprintf("true=\"%v\"", f.getTrue())) - toString = append(toString, fmt.Sprintf("false=\"%v\"", f.getFalse())) - toString = append(toString, fmt.Sprintf("default=\"%v\"", f.getDefault())) - toString = append(toString, fmt.Sprintf("disable=\"%v\"", f.IsDisable())) - - if f.TrackEvents != nil { - toString = append(toString, fmt.Sprintf("trackEvents=\"%v\"", f.IsTrackEvents())) - } - - if f.Version != nil { - toString = append(toString, fmt.Sprintf("version=%s", f.GetVersion())) - } - - return strings.Join(toString, ", ") -} - -// getActualPercentage return the the actual percentage of the flag. -// the result value is the version with the percentageMultiplier. -func (f *FlagData) getActualPercentage() float64 { - flagPercentage := f.getPercentage() * percentageMultiplier - if f.Rollout == nil || f.Rollout.Progressive == nil { - return flagPercentage - } - - // compute progressive rollout percentage - now := time.Now() - - // Missing date we ignore the progressive rollout - if f.Rollout.Progressive.ReleaseRamp.Start == nil || f.Rollout.Progressive.ReleaseRamp.End == nil { - return flagPercentage - } - // Expand percentage with the percentageMultiplier - initialPercentage := f.Rollout.Progressive.Percentage.Initial * percentageMultiplier - if f.Rollout.Progressive.Percentage.End == 0 { - f.Rollout.Progressive.Percentage.End = 100 - } - endPercentage := f.Rollout.Progressive.Percentage.End * percentageMultiplier - - if f.Rollout.Progressive.Percentage.Initial > f.Rollout.Progressive.Percentage.End { - return flagPercentage - } - - // Not in the range of the progressive rollout - if now.Before(*f.Rollout.Progressive.ReleaseRamp.Start) { - return initialPercentage - } - if now.After(*f.Rollout.Progressive.ReleaseRamp.End) { - return endPercentage - } - - // during the rollout ramp we compute the percentage - nbSec := f.Rollout.Progressive.ReleaseRamp.End.Unix() - f.Rollout.Progressive.ReleaseRamp.Start.Unix() - percentage := endPercentage - initialPercentage - percentPerSec := percentage / float64(nbSec) - - c := now.Unix() - f.Rollout.Progressive.ReleaseRamp.Start.Unix() - currentPercentage := float64(c)*percentPerSec + initialPercentage - return currentPercentage -} - -func (f *FlagData) updateFlagStage() { - if f.Rollout == nil || f.Rollout.Scheduled == nil || len(f.Rollout.Scheduled.Steps) == 0 { - // no update required because no scheduled rollout configuration - return - } - - now := time.Now() - for _, step := range f.Rollout.Scheduled.Steps { - // if the step has no date we ignore it - if step.Date == nil { - continue - } - - // as soon as we have a step in the future we stop the updates - if now.Before(*step.Date) { - break - } - - if step.Date != nil && now.After(*step.Date) { - f.mergeChanges(step) - } - } -} - -// mergeChanges will check every changes on the flag and apply them to the current configuration. -func (f *FlagData) mergeChanges(stepFlag ScheduledStep) { - if stepFlag.Disable != nil { - f.Disable = stepFlag.Disable - } - if stepFlag.False != nil { - f.False = stepFlag.False - } - if stepFlag.True != nil { - f.True = stepFlag.True - } - if stepFlag.Default != nil { - f.Default = stepFlag.Default - } - if stepFlag.TrackEvents != nil { - f.TrackEvents = stepFlag.TrackEvents - } - if stepFlag.Percentage != nil { - f.Percentage = stepFlag.Percentage - } - if stepFlag.Rule != nil { - f.Rule = stepFlag.Rule - } - if stepFlag.Rollout != nil { - f.Rollout = stepFlag.Rollout - } - if stepFlag.Version != nil { - f.Version = stepFlag.Version - } -} - -// GetRule is the getter of the field Rule -func (f *FlagData) getRule() string { - if f.Rule == nil { - return "" - } - return *f.Rule -} - -// GetPercentage is the getter of the field Percentage -func (f *FlagData) getPercentage() float64 { - if f.Percentage == nil { - return 0 - } - return *f.Percentage -} - -// GetTrue is the getter of the field True -func (f *FlagData) getTrue() interface{} { - if f.True == nil { - return nil - } - return *f.True -} - -// f.getFalse is the getter of the field False -func (f *FlagData) getFalse() interface{} { - if f.False == nil { - return nil - } - return *f.False -} - -// GetDefault is the getter of the field Default -func (f *FlagData) getDefault() interface{} { - if f.Default == nil { - return nil - } - return *f.Default -} - -// IsTrackEvents is the getter of the field TrackEvents -func (f *FlagData) IsTrackEvents() bool { - if f.TrackEvents == nil { - return true - } - return *f.TrackEvents -} - -// IsDisable is the getter for the field Disable -func (f *FlagData) IsDisable() bool { - if f.Disable == nil { - return false - } - return *f.Disable -} - -// GetRollout is the getter for the field Rollout -func (f *FlagData) getRollout() *Rollout { - return f.Rollout -} - -// GetVersion is the getter for the field Version -func (f *FlagData) GetVersion() string { - if f.Version == nil { - return "" - } - return strconv.FormatFloat(*f.Version, 'f', -1, 64) -} - -// GetVariationValue return the value of variation from his name -func (f *FlagData) GetVariationValue(variationName string) interface{} { - switch variationName { - case VariationDefault: - return f.getDefault() - case VariationTrue: - return f.getTrue() - case VariationFalse: - return f.getFalse() - default: - return nil - } -} - -func (f *FlagData) GetDefaultVariation() string { - return VariationDefault -} - -func (f *FlagData) GetRawValues() map[string]string { - rawValues := make(map[string]string) - rawValues["Rule"] = f.getRule() - rawValues["Percentage"] = fmt.Sprintf("%.2f", f.getPercentage()) - - if f.getRollout() == nil { - rawValues["Rollout"] = "" - } else { - rawValues["Rollout"] = fmt.Sprintf("%v", f.getRollout()) - } - rawValues["True"] = convertNilEmpty(f.getTrue()) - rawValues["False"] = convertNilEmpty(f.getFalse()) - rawValues["Default"] = convertNilEmpty(f.getDefault()) - rawValues["TrackEvents"] = fmt.Sprintf("%t", f.IsTrackEvents()) - rawValues["Disable"] = fmt.Sprintf("%t", f.IsDisable()) - rawValues["Version"] = fmt.Sprintf("%v", f.GetVersion()) - return rawValues -} - -func convertNilEmpty(input interface{}) string { - if input == nil { - return "" - } - return fmt.Sprintf("%v", input) -} diff --git a/internal/flagv1/flag_priv_test.go b/internal/flagv1/flag_priv_test.go deleted file mode 100644 index f1989e9146d..00000000000 --- a/internal/flagv1/flag_priv_test.go +++ /dev/null @@ -1,449 +0,0 @@ -package flagv1 - -import ( - "testing" - "time" - - "github.com/stretchr/testify/assert" - - "github.com/thomaspoignant/go-feature-flag/ffuser" - "github.com/thomaspoignant/go-feature-flag/testutils/testconvert" -) - -func TestFlag_evaluateRule(t *testing.T) { - type fields struct { - Disable bool - Rule string - Percentage float64 - True interface{} - False interface{} - } - type args struct { - user ffuser.User - env string - } - tests := []struct { - name string - fields fields - args args - want bool - }{ - { - name: "Toggle enabled and no rule", - fields: fields{ - Disable: false, - }, - args: args{ - user: ffuser.NewAnonymousUser("random-key"), - }, - want: true, - }, - { - name: "Toggle enabled with rule success", - fields: fields{ - Rule: "key == \"random-key\"", - }, - args: args{ - user: ffuser.NewAnonymousUser("random-key"), - }, - want: true, - }, - { - name: "Toggle enabled with rule failure", - fields: fields{ - Rule: "key == \"incorrect-key\"", - }, - args: args{ - user: ffuser.NewAnonymousUser("random-key"), - }, - want: false, - }, - { - name: "Toggle enabled with no key", - fields: fields{ - Rule: "key == \"random-key\"", - }, - args: args{ - user: ffuser.NewAnonymousUser(""), - }, - want: false, - }, - { - name: "Rolled out to environment", - fields: fields{ - Rule: "env == \"staging\"", - }, - args: args{ - user: ffuser.NewAnonymousUser(""), - env: "staging", - }, - want: true, - }, - { - name: "Not rolled out to environment", - fields: fields{ - Rule: "env != \"production\"", - }, - args: args{ - user: ffuser.NewAnonymousUser(""), - env: "production", - }, - want: false, - }, - } - for _, tt := range tests { - t.Run(tt.name, func(t *testing.T) { - f := &FlagData{ - Disable: testconvert.Bool(tt.fields.Disable), - Rule: testconvert.String(tt.fields.Rule), - Percentage: testconvert.Float64(tt.fields.Percentage), - True: testconvert.Interface(tt.fields.True), - False: testconvert.Interface(tt.fields.False), - } - - got := f.evaluateRule(tt.args.user, tt.args.env) - assert.Equal(t, tt.want, got) - }) - } -} - -func TestFlag_isInPercentage(t *testing.T) { - type fields struct { - Disable bool - Rule string - Percentage float64 - True interface{} - False interface{} - } - type args struct { - flagName string - user ffuser.User - } - tests := []struct { - name string - fields fields - args args - want bool - }{ - { - name: "Anything should work at 100%", - fields: fields{ - Percentage: 100, - }, - args: args{ - flagName: "test_689025", - user: ffuser.NewUser("test_689053"), - }, - want: true, - }, - { - name: "105% should work as 100%", - fields: fields{ - Percentage: 105, - }, - args: args{ - flagName: "test_689025", - user: ffuser.NewUser("test_689053"), - }, - want: true, - }, - { - name: "Anything should work at 0%", - fields: fields{ - Percentage: 0, - }, - args: args{ - flagName: "test_689025", - user: ffuser.NewUser("test_689053"), - }, - want: false, - }, - { - name: "-1% should work like 0%", - fields: fields{ - Percentage: -1, - }, - args: args{ - flagName: "test_689025", - user: ffuser.NewUser("test_689053"), - }, - want: false, - }, - { - name: "User flag in the range", - fields: fields{ - Percentage: 10, - }, - args: args{ - flagName: "test-flag", - user: ffuser.NewUser("86fe0fd9-d19c-4c35-bd05-07b434a21c04"), - }, - want: true, - }, - { - name: "High limit of the percentage", - fields: fields{ - Percentage: 10, - }, - args: args{ - flagName: "test-flag", - user: ffuser.NewUser("7e50ee61-06ad-4bb0-9034-38ad7cdea9f5"), - }, - want: true, - }, - { - name: "Limit +1", - fields: fields{ - Percentage: 10, - }, - args: args{ - flagName: "test-flag", - user: ffuser.NewUser("a287f16a-b50b-4151-a50f-a97fe334a4bf"), - }, - want: false, - }, - { - name: "Low limit of the percentage", - fields: fields{ - Percentage: 10, - }, - args: args{ - flagName: "test-flag", - user: ffuser.NewUser("a4599f14-f7a3-4c14-b3b9-0c0d728224ff"), - }, - want: true, - }, - { - name: "Flag not in the percentage", - fields: fields{ - Percentage: 10, - }, - args: args{ - flagName: "test-flag", - user: ffuser.NewUser("ffc35559-bc1d-4cf3-8e21-7f95c432d1c2"), - }, - want: false, - }, - { - name: "float percentage", - fields: fields{ - Percentage: 10.123, - }, - args: args{ - flagName: "test-flag", - user: ffuser.NewUser("ffc35559-bc1d-4cf3-8e21-7f95c432d1c2"), - }, - want: false, - }, - } - for _, tt := range tests { - t.Run(tt.name, func(t *testing.T) { - f := &FlagData{ - Disable: testconvert.Bool(tt.fields.Disable), - Rule: testconvert.String(tt.fields.Rule), - Percentage: testconvert.Float64(tt.fields.Percentage), - True: testconvert.Interface(tt.fields.True), - False: testconvert.Interface(tt.fields.False), - } - - got := f.isInPercentage(tt.args.flagName, tt.args.user) - assert.Equal(t, tt.want, got) - }) - } -} - -func TestFlag_getPercentage(t *testing.T) { - tests := []struct { - name string - flag FlagData - want float64 - }{ - { - name: "No rollout strategy 100", - flag: FlagData{ - Percentage: testconvert.Float64(100), - }, - want: 100 * percentageMultiplier, - }, - { - name: "No rollout strategy 0", - flag: FlagData{ - Percentage: testconvert.Float64(0), - }, - want: 0 * percentageMultiplier, - }, - { - name: "No rollout strategy 50", - flag: FlagData{ - Percentage: testconvert.Float64(50), - }, - want: 50 * percentageMultiplier, - }, - { - name: "Progressive rollout no explicit percentage", - flag: FlagData{ - Rollout: &Rollout{ - Progressive: &Progressive{ - ReleaseRamp: ProgressiveReleaseRamp{ - Start: testconvert.Time(time.Now().Add(-1 * time.Minute)), - End: testconvert.Time(time.Now().Add(1 * time.Minute)), - }, - }, - }, - }, - want: 50 * percentageMultiplier, - }, - { - name: "Progressive rollout explicit initial percentage", - flag: FlagData{ - Rollout: &Rollout{ - Progressive: &Progressive{ - Percentage: ProgressivePercentage{ - Initial: 20, - }, - ReleaseRamp: ProgressiveReleaseRamp{ - Start: testconvert.Time(time.Now().Add(-1 * time.Minute)), - End: testconvert.Time(time.Now().Add(1 * time.Minute)), - }, - }, - }, - }, - want: float64(60000), - }, - { - name: "Progressive rollout explicit end percentage", - flag: FlagData{ - Rollout: &Rollout{ - Progressive: &Progressive{ - Percentage: ProgressivePercentage{ - End: 20, - }, - ReleaseRamp: ProgressiveReleaseRamp{ - Start: testconvert.Time(time.Now().Add(-1 * time.Minute)), - End: testconvert.Time(time.Now().Add(1 * time.Minute)), - }, - }, - }, - }, - want: float64(10000), - }, - { - name: "Progressive rollout explicit initial and end percentage", - flag: FlagData{ - Rollout: &Rollout{ - Progressive: &Progressive{ - Percentage: ProgressivePercentage{ - Initial: 10, - End: 20, - }, - ReleaseRamp: ProgressiveReleaseRamp{ - Start: testconvert.Time(time.Now().Add(-1 * time.Minute)), - End: testconvert.Time(time.Now().Add(1 * time.Minute)), - }, - }, - }, - }, - want: float64(15000), - }, - { - name: "Progressive rollout before date", - flag: FlagData{ - Rollout: &Rollout{ - Progressive: &Progressive{ - Percentage: ProgressivePercentage{ - Initial: 10, - End: 20, - }, - ReleaseRamp: ProgressiveReleaseRamp{ - Start: testconvert.Time(time.Now().Add(1 * time.Minute)), - End: testconvert.Time(time.Now().Add(2 * time.Minute)), - }, - }, - }, - }, - want: float64(10000), - }, - { - name: "Progressive rollout after date", - flag: FlagData{ - Rollout: &Rollout{ - Progressive: &Progressive{ - Percentage: ProgressivePercentage{ - Initial: 10, - End: 80, - }, - ReleaseRamp: ProgressiveReleaseRamp{ - Start: testconvert.Time(time.Now().Add(-1 * time.Minute)), - End: testconvert.Time(time.Now().Add(-2 * time.Minute)), - }, - }, - }, - }, - want: float64(80000), - }, - { - name: "End percentage lower than start use top level percentage", - flag: FlagData{ - Rollout: &Rollout{ - Progressive: &Progressive{ - Percentage: ProgressivePercentage{ - Initial: 80, - End: 10, - }, - ReleaseRamp: ProgressiveReleaseRamp{ - Start: testconvert.Time(time.Now().Add(-1 * time.Minute)), - End: testconvert.Time(time.Now().Add(1 * time.Minute)), - }, - }, - }, - }, - want: float64(0), - }, - { - name: "Missing end date", - flag: FlagData{ - Rollout: &Rollout{ - Progressive: &Progressive{ - ReleaseRamp: ProgressiveReleaseRamp{ - Start: testconvert.Time(time.Now().Add(-1 * time.Minute)), - }, - }, - }, - }, - want: float64(0), - }, - { - name: "Missing start date", - flag: FlagData{ - Rollout: &Rollout{ - Progressive: &Progressive{ - ReleaseRamp: ProgressiveReleaseRamp{ - End: testconvert.Time(time.Now().Add(-1 * time.Minute)), - }, - }, - }, - }, - want: float64(0), - }, - { - name: "Missing date use default percentage", - flag: FlagData{ - Percentage: testconvert.Float64(46), - Rollout: &Rollout{ - Progressive: &Progressive{ - ReleaseRamp: ProgressiveReleaseRamp{ - End: testconvert.Time(time.Now().Add(-1 * time.Minute)), - }, - }, - }, - }, - want: float64(46000), - }, - } - for _, tt := range tests { - t.Run(tt.name, func(t *testing.T) { - got := tt.flag.getActualPercentage() - assert.Equal(t, tt.want, got) - }) - } -} diff --git a/internal/flagv1/flag_pub_test.go b/internal/flagv1/flag_pub_test.go deleted file mode 100644 index ac86104fa20..00000000000 --- a/internal/flagv1/flag_pub_test.go +++ /dev/null @@ -1,725 +0,0 @@ -package flagv1_test - -import ( - "testing" - "time" - - "github.com/stretchr/testify/assert" - "github.com/thomaspoignant/go-feature-flag/internal/flag" - flagv1 "github.com/thomaspoignant/go-feature-flag/internal/flagv1" - - "github.com/thomaspoignant/go-feature-flag/ffuser" - "github.com/thomaspoignant/go-feature-flag/testutils/testconvert" -) - -func TestFlag_value(t *testing.T) { - type fields struct { - Disable bool - Rule string - Percentage float64 - True interface{} - False interface{} - Default interface{} - Rollout flagv1.Rollout - } - type args struct { - flagName string - user ffuser.User - sdkDefault string - } - type want struct { - value interface{} - resolutionDetails flag.ResolutionDetails - } - tests := []struct { - name string - fields fields - args args - want want - }{ - { - name: "Flag disable get default value", - fields: fields{ - Disable: true, - True: "true", - False: "false", - Default: "default", - }, - args: args{ - flagName: "test_689483", - user: ffuser.NewUser("test_689483"), - sdkDefault: "defaultSDK", - }, - want: want{ - value: "defaultSDK", - resolutionDetails: flag.ResolutionDetails{ - Variant: flag.VariationSDKDefault, - Reason: flag.ReasonDisabled, - ErrorCode: "", - }, - }, - }, - { - name: "Get true value if rule pass", - fields: fields{ - True: "true", - False: "false", - Default: "default", - Rule: "key == \"7e50ee61-06ad-4bb0-9034-38ad7cdea9f5\"", - Percentage: 10, - }, - args: args{ - flagName: "test-flag", - user: ffuser.NewUserBuilder("7e50ee61-06ad-4bb0-9034-38ad7cdea9f5").AddCustom("name", "john").Build(), // combined hash is 9 - }, - want: want{ - value: "true", - resolutionDetails: flag.ResolutionDetails{ - Variant: flagv1.VariationTrue, - Reason: flag.ReasonSplit, - ErrorCode: "", - }, - }, - }, - { - name: "Rollout ExperimentationRollout only start date in the past", - fields: fields{ - True: "true", - False: "false", - Default: "default", - Rule: "key == \"7e50ee61-06ad-4bb0-9034-38ad7cdea9f5\"", - Percentage: 10, - Rollout: flagv1.Rollout{ - Experimentation: &flagv1.Experimentation{ - Start: testconvert.Time(time.Now().Add(-1 * time.Minute)), - End: nil, - }, - }, - }, - args: args{ - flagName: "test-flag", - user: ffuser.NewUserBuilder("7e50ee61-06ad-4bb0-9034-38ad7cdea9f5").AddCustom("name", "john").Build(), - }, - want: want{ - value: "true", - resolutionDetails: flag.ResolutionDetails{ - Variant: flagv1.VariationTrue, - Reason: flag.ReasonSplit, - ErrorCode: "", - }, - }, - }, - { - name: "Rollout ExperimentationRollout only start date in the future", - fields: fields{ - True: "true", - False: "false", - Default: "default", - Rule: "key == \"user66\"", - Percentage: 10, - Rollout: flagv1.Rollout{ - Experimentation: &flagv1.Experimentation{ - Start: testconvert.Time(time.Now().Add(1 * time.Minute)), - End: nil, - }, - }, - }, - args: args{ - flagName: "test-flag", - user: ffuser.NewUserBuilder("user66").AddCustom("name", "john").Build(), // combined hash is 9 - }, - want: want{ - value: "default", - resolutionDetails: flag.ResolutionDetails{ - Variant: flagv1.VariationDefault, - Reason: flag.ReasonDefault, - ErrorCode: "", - }, - }, - }, - { - name: "Rollout ExperimentationRollout between start and end date", - fields: fields{ - True: "true", - False: "false", - Default: "default", - Rule: "key == \"7e50ee61-06ad-4bb0-9034-38ad7cdea9f5\"", - Percentage: 10, - Rollout: flagv1.Rollout{ - Experimentation: &flagv1.Experimentation{ - Start: testconvert.Time(time.Now().Add(-1 * time.Minute)), - End: testconvert.Time(time.Now().Add(1 * time.Minute)), - }, - }, - }, - args: args{ - flagName: "test-flag", - user: ffuser.NewUserBuilder("7e50ee61-06ad-4bb0-9034-38ad7cdea9f5").AddCustom("name", "john").Build(), - }, - want: want{ - value: "true", - resolutionDetails: flag.ResolutionDetails{ - Variant: flagv1.VariationTrue, - Reason: flag.ReasonSplit, - ErrorCode: "", - }, - }, - }, - { - name: "Rollout ExperimentationRollout not started yet", - fields: fields{ - True: "true", - False: "false", - Default: "default", - Rule: "key == \"user66\"", - Percentage: 10, - Rollout: flagv1.Rollout{ - Experimentation: &flagv1.Experimentation{ - Start: testconvert.Time(time.Now().Add(1 * time.Minute)), - End: testconvert.Time(time.Now().Add(2 * time.Minute)), - }, - }, - }, - args: args{ - flagName: "test-flag", - user: ffuser.NewUserBuilder("user66").AddCustom("name", "john").Build(), // combined hash is 9 - }, - want: want{ - value: "default", - resolutionDetails: flag.ResolutionDetails{ - Variant: flagv1.VariationDefault, - Reason: flag.ReasonDefault, - ErrorCode: "", - }, - }, - }, - { - name: "Rollout ExperimentationRollout finished", - fields: fields{ - True: "true", - False: "false", - Default: "default", - Rule: "key == \"user66\"", - Percentage: 10, - Rollout: flagv1.Rollout{ - Experimentation: &flagv1.Experimentation{ - Start: testconvert.Time(time.Now().Add(-2 * time.Minute)), - End: testconvert.Time(time.Now().Add(-1 * time.Minute)), - }, - }, - }, - args: args{ - flagName: "test-flag", - user: ffuser.NewUserBuilder("user66").AddCustom("name", "john").Build(), // combined hash is 9 - }, - want: want{ - value: "default", - resolutionDetails: flag.ResolutionDetails{ - Variant: flagv1.VariationDefault, - Reason: flag.ReasonDefault, - ErrorCode: "", - }, - }, - }, - { - name: "Rollout ExperimentationRollout only end date finished", - fields: fields{ - True: "true", - False: "false", - Default: "default", - Rule: "key == \"user66\"", - Percentage: 10, - Rollout: flagv1.Rollout{ - Experimentation: &flagv1.Experimentation{ - Start: nil, - End: testconvert.Time(time.Now().Add(-1 * time.Minute)), - }, - }, - }, - args: args{ - flagName: "test-flag", - user: ffuser.NewUserBuilder("user66").AddCustom("name", "john").Build(), // combined hash is 9 - }, - want: want{ - value: "default", - resolutionDetails: flag.ResolutionDetails{ - Variant: flagv1.VariationDefault, - Reason: flag.ReasonDefault, - ErrorCode: "", - }, - }, - }, - { - name: "Rollout ExperimentationRollout only end date not finished", - fields: fields{ - True: "true", - False: "false", - Default: "default", - Rule: "key == \"7e50ee61-06ad-4bb0-9034-38ad7cdea9f5\"", - Percentage: 10, - Rollout: flagv1.Rollout{ - Experimentation: &flagv1.Experimentation{ - Start: nil, - End: testconvert.Time(time.Now().Add(1 * time.Minute)), - }, - }, - }, - args: args{ - flagName: "test-flag", - user: ffuser.NewUserBuilder("7e50ee61-06ad-4bb0-9034-38ad7cdea9f5").AddCustom("name", "john").Build(), - }, - want: want{ - value: "true", - resolutionDetails: flag.ResolutionDetails{ - Variant: flagv1.VariationTrue, - Reason: flag.ReasonSplit, - ErrorCode: "", - }, - }, - }, - { - name: "Rollout ExperimentationRollout only end date not finished", - fields: fields{ - True: "true", - False: "false", - Default: "default", - Rule: "key == \"7e50ee61-06ad-4bb0-9034-38ad7cdea9f5\"", - Percentage: 10, - Rollout: flagv1.Rollout{ - Experimentation: &flagv1.Experimentation{ - Start: nil, - End: nil, - }, - }, - }, - args: args{ - flagName: "test-flag", - user: ffuser.NewUserBuilder("7e50ee61-06ad-4bb0-9034-38ad7cdea9f5").AddCustom("name", "john").Build(), - }, - want: want{ - value: "true", - resolutionDetails: flag.ResolutionDetails{ - Variant: flagv1.VariationTrue, - Reason: flag.ReasonSplit, - ErrorCode: "", - }, - }, - }, - { - name: "Invert start date and end date", - fields: fields{ - True: "true", - False: "false", - Default: "default", - Rule: "key == \"user66\"", - Percentage: 10, - Rollout: flagv1.Rollout{ - Experimentation: &flagv1.Experimentation{ - Start: testconvert.Time(time.Now().Add(1 * time.Minute)), - End: testconvert.Time(time.Now().Add(-1 * time.Minute)), - }, - }, - }, - args: args{ - flagName: "test-flag", - user: ffuser.NewUserBuilder("user66").AddCustom("name", "john").Build(), // combined hash is 9 - }, - want: want{ - value: "default", - resolutionDetails: flag.ResolutionDetails{ - Variant: flagv1.VariationDefault, - Reason: flag.ReasonDefault, - ErrorCode: "", - }, - }, - }, - { - name: "Get default value if does not pass", - fields: fields{ - True: "true", - False: "false", - Default: "default", - Rule: "key == \"7e50ee61-06ad-4bb0-9034-38ad7\"", - Percentage: 10, - }, - args: args{ - flagName: "test-flag", - user: ffuser.NewUserBuilder("7e50ee61-06ad-4bb0-9034-38ad7cdea9f5").AddCustom("name", "john").Build(), - }, - want: want{ - value: "default", - resolutionDetails: flag.ResolutionDetails{ - Variant: flagv1.VariationDefault, - Reason: flag.ReasonDefault, - ErrorCode: "", - }, - }, - }, - { - name: "Get false value if rule pass and not in the cohort", - fields: fields{ - True: "true", - False: "false", - Default: "default", - Rule: "key == \"7e50ee61-06ad-4bb0-9034-38ad7cdea9f5\"", - Percentage: 10, - }, - args: args{ - flagName: "test-flag2", - user: ffuser.NewUserBuilder("7e50ee61-06ad-4bb0-9034-38ad7cdea9f5").AddCustom("name", "john").Build(), - }, - want: want{ - value: "false", - resolutionDetails: flag.ResolutionDetails{ - Variant: flagv1.VariationFalse, - Reason: flag.ReasonSplit, - ErrorCode: "", - }, - }, - }, - { - name: "Flag target everyone", - fields: fields{ - True: "true", - False: "false", - Default: "default", - Percentage: 100, - }, - args: args{ - flagName: "test-flag2", - user: ffuser.NewUserBuilder("7e50ee61-06ad-4bb0-9034-38ad7cdea9f5").AddCustom("name", "john").Build(), - }, - want: want{ - value: "true", - resolutionDetails: flag.ResolutionDetails{ - Variant: flagv1.VariationTrue, - Reason: flag.ReasonTargetingMatch, - ErrorCode: "", - }, - }, - }, - } - for _, tt := range tests { - t.Run(tt.name, func(t *testing.T) { - f := &flagv1.FlagData{ - Disable: testconvert.Bool(tt.fields.Disable), - Rule: testconvert.String(tt.fields.Rule), - Percentage: testconvert.Float64(tt.fields.Percentage), - True: testconvert.Interface(tt.fields.True), - False: testconvert.Interface(tt.fields.False), - Default: testconvert.Interface(tt.fields.Default), - Rollout: &tt.fields.Rollout, - } - - got, resolutionDetails := f.Value(tt.args.flagName, tt.args.user, - flag.EvaluationContext{DefaultSdkValue: tt.args.sdkDefault}) - assert.Equal(t, tt.want.value, got) - assert.Equal(t, tt.want.resolutionDetails, resolutionDetails) - }) - } -} - -func TestFlag_ProgressiveRollout(t *testing.T) { - f := &flagv1.FlagData{ - Percentage: testconvert.Float64(0), - True: testconvert.Interface("True"), - False: testconvert.Interface("False"), - Default: testconvert.Interface("Default"), - Rollout: &flagv1.Rollout{Progressive: &flagv1.Progressive{ - ReleaseRamp: flagv1.ProgressiveReleaseRamp{ - Start: testconvert.Time(time.Now().Add(1 * time.Second)), - End: testconvert.Time(time.Now().Add(2 * time.Second)), - }, - }}, - } - - user := ffuser.NewAnonymousUser("test") - flagName := "test-flag" - - // We evaluate the same flag multiple time overtime. - v, _ := f.Value(flagName, user, flag.EvaluationContext{}) - assert.Equal(t, f.GetVariationValue(flagv1.VariationFalse), v) - - time.Sleep(1 * time.Second) - v2, _ := f.Value(flagName, user, flag.EvaluationContext{}) - assert.Equal(t, f.GetVariationValue(flagv1.VariationFalse), v2) - - time.Sleep(1 * time.Second) - v3, _ := f.Value(flagName, user, flag.EvaluationContext{}) - assert.Equal(t, f.GetVariationValue(flagv1.VariationTrue), v3) -} - -func TestFlag_ScheduledRollout(t *testing.T) { - f := &flagv1.FlagData{ - Rule: testconvert.String("key eq \"test\""), - Percentage: testconvert.Float64(0), - True: testconvert.Interface("True"), - False: testconvert.Interface("False"), - Default: testconvert.Interface("Default"), - Rollout: &flagv1.Rollout{ - Scheduled: &flagv1.ScheduledRollout{ - Steps: []flagv1.ScheduledStep{ - { - FlagData: flagv1.FlagData{ - Version: testconvert.Float64(1.1), - }, - Date: testconvert.Time(time.Now().Add(1 * time.Second)), - }, - { - FlagData: flagv1.FlagData{ - Percentage: testconvert.Float64(100), - }, - Date: testconvert.Time(time.Now().Add(1 * time.Second)), - }, - { - FlagData: flagv1.FlagData{ - True: testconvert.Interface("True2"), - False: testconvert.Interface("False2"), - Default: testconvert.Interface("Default2"), - Rule: testconvert.String("key eq \"test2\""), - }, - Date: testconvert.Time(time.Now().Add(2 * time.Second)), - }, - { - FlagData: flagv1.FlagData{ - True: testconvert.Interface("True2"), - False: testconvert.Interface("False2"), - Default: testconvert.Interface("Default2"), - Rule: testconvert.String("key eq \"test\""), - }, - Date: testconvert.Time(time.Now().Add(3 * time.Second)), - }, - { - FlagData: flagv1.FlagData{ - Disable: testconvert.Bool(true), - }, - Date: testconvert.Time(time.Now().Add(4 * time.Second)), - }, - { - FlagData: flagv1.FlagData{ - Percentage: testconvert.Float64(0), - }, - }, - { - FlagData: flagv1.FlagData{ - Disable: testconvert.Bool(false), - TrackEvents: testconvert.Bool(true), - Rollout: &flagv1.Rollout{ - Experimentation: &flagv1.Experimentation{ - Start: testconvert.Time(time.Now().Add(6 * time.Second)), - End: testconvert.Time(time.Now().Add(7 * time.Second)), - }, - }, - }, - Date: testconvert.Time(time.Now().Add(5 * time.Second)), - }, - }, - }, - }, - } - - user := ffuser.NewAnonymousUser("test") - flagName := "test-flag" - - // We evaluate the same flag multiple time overtime. - v, _ := f.Value(flagName, user, flag.EvaluationContext{}) - assert.Equal(t, f.GetVariationValue(flagv1.VariationFalse), v) - - time.Sleep(1 * time.Second) - - v, _ = f.Value(flagName, user, flag.EvaluationContext{}) - assert.Equal(t, "True", v) - assert.Equal(t, "1.1", f.GetVersion()) - - time.Sleep(1 * time.Second) - - v, _ = f.Value(flagName, user, flag.EvaluationContext{}) - assert.Equal(t, "Default2", v) - - time.Sleep(1 * time.Second) - - v, _ = f.Value(flagName, user, flag.EvaluationContext{}) - assert.Equal(t, "True2", v) - - time.Sleep(1 * time.Second) - - v, _ = f.Value(flagName, user, flag.EvaluationContext{DefaultSdkValue: "Default2"}) - assert.Equal(t, "Default2", v) - - time.Sleep(1 * time.Second) - - v, _ = f.Value(flagName, user, flag.EvaluationContext{}) - assert.Equal(t, "Default2", v) - - time.Sleep(1 * time.Second) - - v, _ = f.Value(flagName, user, flag.EvaluationContext{}) - assert.Equal(t, "True2", v) - - time.Sleep(1 * time.Second) - - v, _ = f.Value(flagName, user, flag.EvaluationContext{}) - assert.Equal(t, "Default2", v) -} - -func TestFlag_String(t *testing.T) { - type fields struct { - Disable bool - Rule string - Percentage float64 - True interface{} - False interface{} - Default interface{} - TrackEvents *bool - Version *float64 - } - tests := []struct { - name string - fields fields - want string - }{ - { - name: "All fields", - fields: fields{ - Disable: false, - Rule: "key eq \"toto\"", - Percentage: 10, - True: true, - False: false, - Default: false, - TrackEvents: testconvert.Bool(true), - Version: testconvert.Float64(12), - }, - want: "percentage=10%, rule=\"key eq \"toto\"\", true=\"true\", false=\"false\", default=\"false\", disable=\"false\", trackEvents=\"true\", version=12", - }, - { - name: "No rule", - fields: fields{ - Disable: false, - Percentage: 10, - True: true, - False: false, - Default: false, - }, - want: "percentage=10%, true=\"true\", false=\"false\", default=\"false\", disable=\"false\"", - }, - { - name: "Default values", - fields: fields{ - True: true, - False: false, - Default: false, - }, - want: "percentage=0%, true=\"true\", false=\"false\", default=\"false\", disable=\"false\"", - }, - } - for _, tt := range tests { - t.Run(tt.name, func(t *testing.T) { - f := &flagv1.FlagData{ - Disable: testconvert.Bool(tt.fields.Disable), - Rule: testconvert.String(tt.fields.Rule), - Percentage: testconvert.Float64(tt.fields.Percentage), - True: testconvert.Interface(tt.fields.True), - False: testconvert.Interface(tt.fields.False), - Default: testconvert.Interface(tt.fields.Default), - TrackEvents: tt.fields.TrackEvents, - Version: tt.fields.Version, - } - got := f.String() - assert.Equal(t, tt.want, got, "String() = %v, want %v", got, tt.want) - }) - } -} - -// func TestFlag_Getter(t *testing.T) { -// type expected struct { -// True interface{} -// False interface{} -// Default interface{} -// Rollout *flagv1.Rollout -// Disable bool -// TrackEvents bool -// Percentage float64 -// Rule string -// Version float64 -// RawValues map[string]string -// } -// tests := []struct { -// name string -// flag flag.Flag -// want expected -// }{ -// { -// name: "all default", -// flag: &flagv1.FlagData{}, -// want: expected{ -// True: nil, -// False: nil, -// Default: nil, -// Rollout: nil, -// Disable: false, -// TrackEvents: true, -// Percentage: 0, -// Rule: "", -// Version: 0, -// RawValues: map[string]string{ -// "Default": "", -// "Disable": "false", -// "False": "", -// "Percentage": "0.00", -// "Rollout": "", -// "Rule": "", -// "TrackEvents": "true", -// "True": "", -// "Version": "0", -// }, -// }, -// }, -// { -// name: "custom flag", -// flag: &flagv1.FlagData{ -// Rule: testconvert.String("test"), -// Percentage: testconvert.Float64(90), -// True: testconvert.Interface(12.2), -// False: testconvert.Interface(13.2), -// Default: testconvert.Interface(14.2), -// TrackEvents: testconvert.Bool(false), -// Disable: testconvert.Bool(true), -// Version: testconvert.Float64(127), -// }, -// want: expected{ -// True: 12.2, -// False: 13.2, -// Default: 14.2, -// Disable: true, -// TrackEvents: false, -// Percentage: 90, -// Rule: "test", -// Version: 127, -// RawValues: map[string]string{ -// "Default": "14.2", -// "Disable": "true", -// "False": "13.2", -// "Percentage": "90.00", -// "Rollout": "", -// "Rule": "test", -// "TrackEvents": "false", -// "True": "12.2", -// "Version": "127", -// }, -// }, -// }, -// } -// -// for _, tt := range tests { -// t.Run(tt.name, func(t *testing.T) { -// assert.Equal(t, tt.want.Disable, tt.flag.IsDisable()) -// assert.Equal(t, tt.want.TrackEvents, tt.flag.GetTrackEvents()) -// assert.Equal(t, tt.want.Version, tt.flag.GetVersion()) -// assert.Equal(t, flagv1.VariationDefault, tt.flag.GetDefaultVariation()) -// fmt.Println(tt.want.Default, tt.flag.GetVariationValue(tt.flag.GetDefaultVariation())) -// assert.Equal(t, tt.want.Default, tt.flag.GetVariationValue(tt.flag.GetDefaultVariation())) -// assert.Equal(t, tt.want.RawValues, tt.flag.GetRawValues()) -// }) -// } -//} diff --git a/internal/flagv1/rollout.go b/internal/flagv1/rollout.go deleted file mode 100644 index 13d14294818..00000000000 --- a/internal/flagv1/rollout.go +++ /dev/null @@ -1,97 +0,0 @@ -package flagv1 - -import ( - "fmt" - "strings" - "time" -) - -type Rollout struct { - // Experimentation is your struct to configure an experimentation, it will allow you to configure a start date and - // an end date for your flag. - // When the experimentation is not running, the flag will serve the default value. - Experimentation *Experimentation `json:"experimentation,omitempty" yaml:"experimentation,omitempty" toml:"experimentation,omitempty"` // nolint: lll - - // Progressive is your struct to configure a progressive rollout deployment of your flag. - // It will allow you to ramp up the percentage of your flag over time. - // You can decide at which percentage you starts and at what percentage you ends in your release ramp. - // Before the start date we will serve the initial percentage and after we will serve the end percentage. - Progressive *Progressive `json:"progressive,omitempty" yaml:"progressive,omitempty" toml:"progressive,omitempty"` // nolint: lll - - // Scheduled is your struct to configure an update on some fields of your flag over time. - // You can add several steps that updates the flag, this is typically used if you want to gradually add more user - // in your flag. - Scheduled *ScheduledRollout `json:"scheduled,omitempty" yaml:"scheduled,omitempty" toml:"scheduled,omitempty"` // nolint: lll -} - -func (e Rollout) String() string { - // TODO: other rollout - if e.Experimentation == nil { - return "" - } - return "experimentation: " + e.Experimentation.String() -} - -type Experimentation struct { - // Start is the starting time of the experimentation - Start *time.Time `json:"start,omitempty" yaml:"start,omitempty" toml:"start,omitempty"` - - // End is the ending time of the experimentation - End *time.Time `json:"end,omitempty" yaml:"end,omitempty" toml:"end,omitempty"` -} - -func (e Experimentation) String() string { - buf := make([]string, 0) - lo, _ := time.LoadLocation("UTC") - - if e.Start != nil { - buf = append(buf, fmt.Sprintf("start:[%v]", e.Start.In(lo).Format(time.RFC3339))) - } - if e.End != nil { - buf = append(buf, fmt.Sprintf("end:[%v]", e.End.In(lo).Format(time.RFC3339))) - } - return strings.Join(buf, " ") -} - -// Progressive is the configuration struct to define a progressive rollout. -type Progressive struct { - // Percentage is where you can configure at what percentage your progressive rollout start - // and at what percentage it ends. - // This field is optional - Percentage ProgressivePercentage `json:"percentage,omitempty" yaml:"percentage,omitempty" toml:"percentage,omitempty"` - - // ReleaseRamp is the defining when the progressive rollout starts and ends. - // This field is mandatory if you want to use a progressive rollout. - // If any field missing we ignore the progressive rollout. - ReleaseRamp ProgressiveReleaseRamp `json:"releaseRamp,omitempty" yaml:"releaseRamp,omitempty" toml:"releaseRamp,omitempty"` // nolint: lll -} - -type ProgressivePercentage struct { - // Initial is the initial percentage before the rollout start date. - // This field is optional - // Default: 0.0 - Initial float64 `json:"initial,omitempty" yaml:"initial,omitempty" toml:"initial,omitempty"` - - // End is the target percentage we want to reach at the end of the rollout phase. - // This field is optional - // Default: 100.0 - End float64 `json:"end,omitempty" yaml:"end,omitempty" toml:"end,omitempty"` -} - -type ProgressiveReleaseRamp struct { - // Start is the starting time of the ramp - Start *time.Time `json:"start,omitempty" yaml:"start,omitempty" toml:"start,omitempty"` - - // End is the ending time of the ramp - End *time.Time `json:"end,omitempty" yaml:"end,omitempty" toml:"end,omitempty"` -} - -type ScheduledRollout struct { - // Steps is the list of updates to do in a specific date. - Steps []ScheduledStep `json:"steps,omitempty" yaml:"steps,omitempty" toml:"steps,omitempty"` -} - -type ScheduledStep struct { - FlagData `yaml:",inline"` - Date *time.Time `json:"date,omitempty" yaml:"date,omitempty" toml:"date,omitempty"` -} diff --git a/internal/flagv1/rollout_test.go b/internal/flagv1/rollout_test.go deleted file mode 100644 index 2a0874c9d87..00000000000 --- a/internal/flagv1/rollout_test.go +++ /dev/null @@ -1,86 +0,0 @@ -package flagv1_test - -import ( - "testing" - "time" - - "github.com/stretchr/testify/assert" - flagv1 "github.com/thomaspoignant/go-feature-flag/internal/flagv1" - - "github.com/thomaspoignant/go-feature-flag/testutils/testconvert" -) - -func TestExperimentation_String(t *testing.T) { - type fields struct { - StartDate *time.Time - EndDate *time.Time - Start *time.Time - End *time.Time - } - tests := []struct { - name string - fields fields - want string - }{ - { - name: "both dates", - fields: fields{ - Start: testconvert.Time(time.Unix(1095379400, 0)), - End: testconvert.Time(time.Unix(1095379500, 0)), - }, - want: "start:[2004-09-17T00:03:20Z] end:[2004-09-17T00:05:00Z]", - }, - { - name: "only start date", - fields: fields{ - Start: testconvert.Time(time.Unix(1095379400, 0)), - }, - want: "start:[2004-09-17T00:03:20Z]", - }, - { - name: "only end date", - fields: fields{ - End: testconvert.Time(time.Unix(1095379500, 0)), - }, - want: "end:[2004-09-17T00:05:00Z]", - }, - } - for _, tt := range tests { - t.Run(tt.name, func(t *testing.T) { - e := flagv1.Experimentation{ - End: tt.fields.End, - Start: tt.fields.Start, - } - got := e.String() - assert.Equal(t, tt.want, got) - }) - } -} - -func TestRollout_String(t *testing.T) { - tests := []struct { - name string - rollout flagv1.Rollout - want string - }{ - { - name: "experimentation", - rollout: flagv1.Rollout{Experimentation: &flagv1.Experimentation{ - Start: testconvert.Time(time.Unix(1095379400, 0)), - End: testconvert.Time(time.Unix(1095379500, 0)), - }}, - want: "experimentation: start:[2004-09-17T00:03:20Z] end:[2004-09-17T00:05:00Z]", - }, - { - name: "empty", - rollout: flagv1.Rollout{}, - want: "", - }, - } - for _, tt := range tests { - t.Run(tt.name, func(t *testing.T) { - got := tt.rollout.String() - assert.Equal(t, tt.want, got) - }) - } -} diff --git a/internal/flagv1/variation_type.go b/internal/flagv1/variation_type.go deleted file mode 100644 index 1b60bdcb7cc..00000000000 --- a/internal/flagv1/variation_type.go +++ /dev/null @@ -1,12 +0,0 @@ -package flagv1 - -const ( - // VariationTrue is a constant to explain that we are using the "True" variation - VariationTrue string = "True" - - // VariationFalse is a constant to explain that we are using the "False" variation - VariationFalse string = "False" - - // VariationDefault is a constant to explain that we are using the "Default" variation - VariationDefault string = "Default" -) From 1514d8962675733d466192487fc6551fdde06609 Mon Sep 17 00:00:00 2001 From: Thomas Poignant Date: Mon, 1 Aug 2022 11:33:15 +0200 Subject: [PATCH 14/50] Disable schedule step in schedule step Signed-off-by: Thomas Poignant --- internal/dto/converter_v0.go | 9 ++++++--- 1 file changed, 6 insertions(+), 3 deletions(-) diff --git a/internal/dto/converter_v0.go b/internal/dto/converter_v0.go index 80ac56842fe..04f0e30e985 100644 --- a/internal/dto/converter_v0.go +++ b/internal/dto/converter_v0.go @@ -50,7 +50,7 @@ func ConvertV0DtoToInternalFlag(d DTO, isScheduleStep bool) flag.InternalFlag { var rollout *flag.Rollout if d.Rollout != nil { - rollout = convertRollout(*d.Rollout) + rollout = convertRollout(*d.Rollout, isScheduleStep) } return flag.InternalFlag{ @@ -124,7 +124,7 @@ func createVariationsV0(d DTO, isScheduleStep bool) map[string]*interface{} { return variations } -func convertRollout(rollout RolloutV0) *flag.Rollout { +func convertRollout(rollout RolloutV0, isScheduledStep bool) *flag.Rollout { r := flag.Rollout{} if rollout.Experimentation != nil && rollout.Experimentation.Start != nil && rollout.Experimentation.End != nil { r.Experimentation = &flag.ExperimentationRollout{ @@ -133,7 +133,8 @@ func convertRollout(rollout RolloutV0) *flag.Rollout { } } - if rollout.Scheduled != nil && rollout.Scheduled.Steps != nil { + // it is not allowed to have a scheduled step inside a scheduled step + if !isScheduledStep && rollout.Scheduled != nil && rollout.Scheduled.Steps != nil { var convertedSteps []flag.ScheduledStep for _, v := range rollout.Scheduled.Steps { converter := "v0" @@ -153,6 +154,8 @@ func convertRollout(rollout RolloutV0) *flag.Rollout { return &r } +// computePercentages is creating the percentage structure based on the +// field percentage in the DTO. func computePercentages(percentage float64) map[string]float64 { return map[string]float64{ trueVariation: percentage, From 988870e1c1a0dad5c4b88b6906f58cc7fe7de209 Mon Sep 17 00:00:00 2001 From: Thomas Poignant Date: Mon, 1 Aug 2022 11:37:23 +0200 Subject: [PATCH 15/50] Add test to ensure we cannot have scheduled step with scheduled steps Signed-off-by: Thomas Poignant --- internal/flag/internal_flag_test.go | 49 +++++++++++++++++++++++++++++ 1 file changed, 49 insertions(+) diff --git a/internal/flag/internal_flag_test.go b/internal/flag/internal_flag_test.go index 8bdeb3121ac..68f4aed7e19 100644 --- a/internal/flag/internal_flag_test.go +++ b/internal/flag/internal_flag_test.go @@ -792,6 +792,55 @@ func TestInternalFlag_Value(t *testing.T) { Reason: flag.ReasonDefault, }, }, + { + name: "Should not apply a scheduled step inside another scheduled step", + flag: flag.InternalFlag{ + Variations: &map[string]*interface{}{ + "variation_A": testconvert.Interface("value_A"), + "variation_B": testconvert.Interface("value_B"), + }, + DefaultRule: &flag.Rule{ + VariationResult: testconvert.String("variation_A"), + }, + Rollout: &flag.Rollout{ + Scheduled: &[]flag.ScheduledStep{ + { + InternalFlag: flag.InternalFlag{ + Variations: &map[string]*interface{}{ + "variation_A": testconvert.Interface("value_AB"), + "variation_B": testconvert.Interface("value_B"), + }, + Rollout: &flag.Rollout{ + Scheduled: &[]flag.ScheduledStep{ + { + InternalFlag: flag.InternalFlag{ + Variations: &map[string]*interface{}{ + "variation_A": testconvert.Interface("value_ABC"), + }, + }, + Date: testconvert.Time(time.Now().Add(-3 * time.Second)), + }, + }, + }, + }, + Date: testconvert.Time(time.Now().Add(-2 * time.Second)), + }, + }, + }, + }, + args: args{ + flagName: "my-flag", + user: ffuser.NewUserBuilder("user-key").Build(), + evaluationCtx: flag.EvaluationContext{ + DefaultSdkValue: "value_default", + }, + }, + want: "value_AB", + want1: flag.ResolutionDetails{ + Variant: "variation_A", + Reason: flag.ReasonDefault, + }, + }, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { From 12f0c21ad22e3934af7a3322ae888135812d961e Mon Sep 17 00:00:00 2001 From: Thomas Poignant Date: Mon, 1 Aug 2022 17:59:26 +0200 Subject: [PATCH 16/50] converter tests --- internal/dto/converter_v0.go | 163 ++++++++---- internal/dto/converter_v0_test.go | 429 ++++++++++++++++++++++++++++++ internal/dto/dto.go | 4 +- internal/dto/rollout_v0.go | 4 +- internal/toremove/toremove.go | 28 -- 5 files changed, 546 insertions(+), 82 deletions(-) create mode 100644 internal/dto/converter_v0_test.go delete mode 100644 internal/toremove/toremove.go diff --git a/internal/dto/converter_v0.go b/internal/dto/converter_v0.go index 04f0e30e985..b18a2c5f6e0 100644 --- a/internal/dto/converter_v0.go +++ b/internal/dto/converter_v0.go @@ -7,21 +7,20 @@ import ( var ( LegacyRuleName = "legacyRuleV0" defaultRuleName = "legacyDefaultRule" -) -var ( - trueVariation = "True" - falseVariation = "False" - defaultVariation = "Default" + trueVariation = "True" + falseVariation = "False" + defaultVariation = "Default" + defaultPercentage = float64(0) ) // ConvertV0DtoToInternalFlag is converting a flag in the config file to the internal format. // this function convert only the old format of the flag (before v1.0.0), to keep // backward support of the configurations. -func ConvertV0DtoToInternalFlag(d DTO, isScheduleStep bool) flag.InternalFlag { +func ConvertV0DtoToInternalFlag(d DTOv0, isScheduledStep bool) flag.InternalFlag { // Create variations based on the available definition in the flag v0 var variations *map[string]*interface{} - newVariations := createVariationsV0(d, isScheduleStep) + newVariations := createVariationsV0(d, isScheduledStep) if newVariations != nil { variations = &newVariations } @@ -33,24 +32,13 @@ func ConvertV0DtoToInternalFlag(d DTO, isScheduleStep bool) flag.InternalFlag { rules = &r } - // Percentage for the default rule - var defaultRule *flag.Rule - if (d.Rule == nil || *d.Rule == "") && d.Percentage != nil { - p := computePercentages(*d.Percentage) - defaultRule = &flag.Rule{ - Name: &defaultRuleName, - Percentages: &p, - } - } else { - defaultRule = &flag.Rule{ - Name: &defaultRuleName, - VariationResult: &defaultVariation, - } - } + // Default rule + hasTargetRule := rules != nil && len(*rules) > 0 + defaultRule := createDefaultLegacyRuleV0(d, hasTargetRule) var rollout *flag.Rollout - if d.Rollout != nil { - rollout = convertRollout(*d.Rollout, isScheduleStep) + if d.Rollout != nil && (d.Rollout.Experimentation != nil || d.Rollout.Scheduled != nil) { + rollout = convertRollout(d, isScheduledStep) } return flag.InternalFlag{ @@ -64,8 +52,50 @@ func ConvertV0DtoToInternalFlag(d DTO, isScheduleStep bool) flag.InternalFlag { } } +// createDefaultLegacyRuleV0 create the default rule based on the legacy format. +func createDefaultLegacyRuleV0(d DTOv0, hasTargetRule bool) *flag.Rule { + hasProgressiveRollout := d.Rollout != nil && + d.Rollout.Progressive != nil && + d.Rollout.Progressive.ReleaseRamp.Start != nil && + d.Rollout.Progressive.ReleaseRamp.End != nil + + if hasProgressiveRollout && !hasTargetRule { + return &flag.Rule{ + Name: &defaultRuleName, + ProgressiveRollout: &flag.ProgressiveRollout{ + Initial: &flag.ProgressiveRolloutStep{ + Variation: &falseVariation, + Percentage: &d.Rollout.Progressive.Percentage.Initial, + Date: d.Rollout.Progressive.ReleaseRamp.Start, + }, + End: &flag.ProgressiveRolloutStep{ + Variation: &trueVariation, + Percentage: &d.Rollout.Progressive.Percentage.End, + Date: d.Rollout.Progressive.ReleaseRamp.End, + }, + }, + } + } + if d.Rule == nil { + if d.Percentage == nil { + d.Percentage = &defaultPercentage + } + + p := computePercentages(*d.Percentage) + return &flag.Rule{ + Name: &defaultRuleName, + Percentages: p, + } + } + + return &flag.Rule{ + Name: &defaultRuleName, + VariationResult: &defaultVariation, + } +} + // createLegacyRuleV0 will create a rule based on the previous format -func createLegacyRuleV0(d DTO) flag.Rule { +func createLegacyRuleV0(d DTOv0) flag.Rule { // Handle the specific use case of progressive rollout. var progressiveRollout *flag.ProgressiveRollout if d.Rollout != nil && @@ -86,27 +116,28 @@ func createLegacyRuleV0(d DTO) flag.Rule { } } - var percentages map[string]float64 - if d.Percentage != nil { - percentages = computePercentages(*d.Percentage) - } else { - percentages = map[string]float64{ - trueVariation: 0, - falseVariation: 100, + var percentages *map[string]float64 + if progressiveRollout == nil { + if d.Percentage != nil { + percentages = computePercentages(*d.Percentage) + } else { + percentages = &map[string]float64{ + trueVariation: 0, + falseVariation: 100, + } } } - legacyRule := flag.Rule{ + + return flag.Rule{ Name: &LegacyRuleName, Query: d.Rule, - Percentages: &percentages, + Percentages: percentages, ProgressiveRollout: progressiveRollout, } - - return legacyRule } // createVariationsV0 will create a set of variations based on the previous format -func createVariationsV0(d DTO, isScheduleStep bool) map[string]*interface{} { +func createVariationsV0(d DTOv0, isScheduleStep bool) map[string]*interface{} { variations := make(map[string]*interface{}, 3) if d.True != nil { variations[trueVariation] = d.True @@ -124,26 +155,27 @@ func createVariationsV0(d DTO, isScheduleStep bool) map[string]*interface{} { return variations } -func convertRollout(rollout RolloutV0, isScheduledStep bool) *flag.Rollout { +func convertRollout(dto DTOv0, isScheduledStep bool) *flag.Rollout { r := flag.Rollout{} - if rollout.Experimentation != nil && rollout.Experimentation.Start != nil && rollout.Experimentation.End != nil { + if dto.Rollout.Experimentation != nil && + dto.Rollout.Experimentation.Start != nil && + dto.Rollout.Experimentation.End != nil { r.Experimentation = &flag.ExperimentationRollout{ - Start: rollout.Experimentation.Start, - End: rollout.Experimentation.End, + Start: dto.Rollout.Experimentation.Start, + End: dto.Rollout.Experimentation.End, } } // it is not allowed to have a scheduled step inside a scheduled step - if !isScheduledStep && rollout.Scheduled != nil && rollout.Scheduled.Steps != nil { + if !isScheduledStep && dto.Rollout.Scheduled != nil && dto.Rollout.Scheduled.Steps != nil { var convertedSteps []flag.ScheduledStep - for _, v := range rollout.Scheduled.Steps { - converter := "v0" - toConvert := DTO{ - DTOv0: v.DTOv0, - Converter: &converter, - } + initialDto := dto + scheduledSteps := dto.Rollout.Scheduled.Steps + initialDto.Rollout.Scheduled = nil + for _, v := range scheduledSteps { + initialDto = mergeDtoScheduledStep(initialDto, v.DTOv0) step := flag.ScheduledStep{ - InternalFlag: ConvertV0DtoToInternalFlag(toConvert, true), + InternalFlag: ConvertV0DtoToInternalFlag(initialDto, false), Date: v.Date, } convertedSteps = append(convertedSteps, step) @@ -156,9 +188,40 @@ func convertRollout(rollout RolloutV0, isScheduledStep bool) *flag.Rollout { // computePercentages is creating the percentage structure based on the // field percentage in the DTO. -func computePercentages(percentage float64) map[string]float64 { - return map[string]float64{ +func computePercentages(percentage float64) *map[string]float64 { + return &map[string]float64{ trueVariation: percentage, falseVariation: 100 - percentage, } } + +func mergeDtoScheduledStep(origin DTOv0, toBeMerged DTOv0) DTOv0 { + if toBeMerged.Disable != nil { + origin.Disable = toBeMerged.Disable + } + if toBeMerged.False != nil { + origin.False = toBeMerged.False + } + if toBeMerged.True != nil { + origin.True = toBeMerged.True + } + if toBeMerged.Default != nil { + origin.Default = toBeMerged.Default + } + if toBeMerged.TrackEvents != nil { + origin.TrackEvents = toBeMerged.TrackEvents + } + if toBeMerged.Percentage != nil { + origin.Percentage = toBeMerged.Percentage + } + if toBeMerged.Rule != nil { + origin.Rule = toBeMerged.Rule + } + if toBeMerged.Rollout != nil { + origin.Rollout = toBeMerged.Rollout + } + if toBeMerged.Version != nil { + origin.Version = toBeMerged.Version + } + return origin +} diff --git a/internal/dto/converter_v0_test.go b/internal/dto/converter_v0_test.go new file mode 100644 index 00000000000..59f47f0ea57 --- /dev/null +++ b/internal/dto/converter_v0_test.go @@ -0,0 +1,429 @@ +package dto_test + +import ( + "testing" + "time" + + "github.com/stretchr/testify/assert" + "github.com/thomaspoignant/go-feature-flag/internal/dto" + "github.com/thomaspoignant/go-feature-flag/internal/flag" + "github.com/thomaspoignant/go-feature-flag/testutils/testconvert" +) + +func TestConvertV0DtoToInternalFlag(t *testing.T) { + tests := []struct { + name string + d dto.DTOv0 + want flag.InternalFlag + }{ + { + name: "Simplest flag, no converter provided", + d: dto.DTOv0{ + True: testconvert.Interface("true"), + False: testconvert.Interface("false"), + Default: testconvert.Interface("default"), + }, + want: flag.InternalFlag{ + Variations: &map[string]*interface{}{ + "Default": testconvert.Interface("default"), + "False": testconvert.Interface("false"), + "True": testconvert.Interface("true"), + }, + Rules: nil, + DefaultRule: &flag.Rule{ + Name: testconvert.String("legacyDefaultRule"), + Percentages: &map[string]float64{ + "True": 0, + "False": 100, + }, + }, + }, + }, + { + name: "Flag with percentage", + d: dto.DTOv0{ + Percentage: testconvert.Float64(10), + True: testconvert.Interface("true"), + False: testconvert.Interface("false"), + Default: testconvert.Interface("default"), + }, + want: flag.InternalFlag{ + Variations: &map[string]*interface{}{ + "Default": testconvert.Interface("default"), + "False": testconvert.Interface("false"), + "True": testconvert.Interface("true"), + }, + DefaultRule: &flag.Rule{ + Name: testconvert.String("legacyDefaultRule"), + Percentages: &map[string]float64{ + "True": 10, + "False": 90, + }, + }, + }, + }, + { + name: "Flag with 100 percentage", + d: dto.DTOv0{ + Percentage: testconvert.Float64(100), + True: testconvert.Interface("true"), + False: testconvert.Interface("false"), + Default: testconvert.Interface("default"), + }, + want: flag.InternalFlag{ + Variations: &map[string]*interface{}{ + "Default": testconvert.Interface("default"), + "False": testconvert.Interface("false"), + "True": testconvert.Interface("true"), + }, + Rules: nil, + DefaultRule: &flag.Rule{ + Name: testconvert.String("legacyDefaultRule"), + Percentages: &map[string]float64{ + "True": 100, + "False": 0, + }, + }, + }, + }, + { + name: "Flag with rule not match", + d: dto.DTOv0{ + Rule: testconvert.String("key eq \"random\""), + True: testconvert.Interface("true"), + False: testconvert.Interface("false"), + Default: testconvert.Interface("default"), + }, + want: flag.InternalFlag{ + Variations: &map[string]*interface{}{ + "Default": testconvert.Interface("default"), + "False": testconvert.Interface("false"), + "True": testconvert.Interface("true"), + }, + Rules: &[]flag.Rule{ + { + Name: testconvert.String("legacyRuleV0"), + Query: testconvert.String("key eq \"random\""), + Percentages: &map[string]float64{ + "True": 0, + "False": 100, + }, + }, + }, + DefaultRule: &flag.Rule{ + Name: testconvert.String("legacyDefaultRule"), + VariationResult: testconvert.String("Default"), + }, + }, + }, + { + name: "Flag with rule match", + d: dto.DTOv0{ + Rule: testconvert.String("key eq \"test-user\""), + True: testconvert.Interface("true"), + False: testconvert.Interface("false"), + Default: testconvert.Interface("default"), + }, + want: flag.InternalFlag{ + Variations: &map[string]*interface{}{ + "Default": testconvert.Interface("default"), + "False": testconvert.Interface("false"), + "True": testconvert.Interface("true"), + }, + Rules: &[]flag.Rule{ + { + Name: testconvert.String("legacyRuleV0"), + Query: testconvert.String("key eq \"test-user\""), + Percentages: &map[string]float64{ + "True": 0, + "False": 100, + }, + }, + }, + DefaultRule: &flag.Rule{ + Name: testconvert.String("legacyDefaultRule"), + VariationResult: testconvert.String("Default"), + }, + }, + }, + { + name: "Flag with rule match + 10% percentage", + d: dto.DTOv0{ + Rule: testconvert.String("key eq \"test-user\""), + Percentage: testconvert.Float64(10), + True: testconvert.Interface("true"), + False: testconvert.Interface("false"), + Default: testconvert.Interface("default"), + }, + want: flag.InternalFlag{ + Variations: &map[string]*interface{}{ + "Default": testconvert.Interface("default"), + "False": testconvert.Interface("false"), + "True": testconvert.Interface("true"), + }, + Rules: &[]flag.Rule{ + { + Name: testconvert.String("legacyRuleV0"), + Query: testconvert.String("key eq \"test-user\""), + Percentages: &map[string]float64{ + "True": 10, + "False": 90, + }, + }, + }, + DefaultRule: &flag.Rule{ + Name: testconvert.String("legacyDefaultRule"), + VariationResult: testconvert.String("Default"), + }, + }, + }, + { + name: "Flag with query + experimentation rollout", + d: dto.DTOv0{ + Rule: testconvert.String("key eq \"test-user\""), + Percentage: testconvert.Float64(100), + True: testconvert.Interface("true"), + False: testconvert.Interface("false"), + Default: testconvert.Interface("default"), + Rollout: &dto.RolloutV0{ + Experimentation: &dto.ExperimentationV0{ + Start: testconvert.Time(time.Date(2021, time.February, 1, 10, 10, 10, 10, time.UTC)), + End: testconvert.Time(time.Date(2021, time.February, 2, 10, 10, 10, 10, time.UTC)), + }, + }, + }, + want: flag.InternalFlag{ + Variations: &map[string]*interface{}{ + "Default": testconvert.Interface("default"), + "False": testconvert.Interface("false"), + "True": testconvert.Interface("true"), + }, + Rules: &[]flag.Rule{ + { + Name: testconvert.String("legacyRuleV0"), + Query: testconvert.String("key eq \"test-user\""), + Percentages: &map[string]float64{ + "True": 100, + "False": 0, + }, + }, + }, + DefaultRule: &flag.Rule{ + Name: testconvert.String("legacyDefaultRule"), + VariationResult: testconvert.String("Default"), + }, + Rollout: &flag.Rollout{ + Experimentation: &flag.ExperimentationRollout{ + Start: testconvert.Time(time.Date(2021, time.February, 1, 10, 10, 10, 10, time.UTC)), + End: testconvert.Time(time.Date(2021, time.February, 2, 10, 10, 10, 10, time.UTC)), + }, + }, + }, + }, + { + name: "Flag with query + progressive rollout", + d: dto.DTOv0{ + Rule: testconvert.String("key eq \"test-user\""), + Percentage: testconvert.Float64(100), + True: testconvert.Interface("true"), + False: testconvert.Interface("false"), + Default: testconvert.Interface("default"), + Rollout: &dto.RolloutV0{ + Progressive: &dto.ProgressiveV0{ + Percentage: dto.ProgressivePercentageV0{ + Initial: 0, + End: 100, + }, + ReleaseRamp: dto.ProgressiveReleaseRampV0{ + Start: testconvert.Time(time.Date(2021, time.February, 1, 10, 10, 10, 10, time.UTC)), + End: testconvert.Time(time.Date(2021, time.February, 2, 10, 10, 10, 10, time.UTC)), + }, + }, + }, + }, + want: flag.InternalFlag{ + Variations: &map[string]*interface{}{ + "Default": testconvert.Interface("default"), + "False": testconvert.Interface("false"), + "True": testconvert.Interface("true"), + }, + Rules: &[]flag.Rule{ + { + Name: testconvert.String("legacyRuleV0"), + Query: testconvert.String("key eq \"test-user\""), + ProgressiveRollout: &flag.ProgressiveRollout{ + Initial: &flag.ProgressiveRolloutStep{ + Variation: testconvert.String("False"), + Percentage: testconvert.Float64(0), + Date: testconvert.Time(time.Date(2021, time.February, 1, 10, 10, 10, 10, time.UTC)), + }, + End: &flag.ProgressiveRolloutStep{ + Variation: testconvert.String("True"), + Percentage: testconvert.Float64(100), + Date: testconvert.Time(time.Date(2021, time.February, 2, 10, 10, 10, 10, time.UTC)), + }, + }, + }, + }, + DefaultRule: &flag.Rule{ + Name: testconvert.String("legacyDefaultRule"), + VariationResult: testconvert.String("Default"), + }, + }, + }, + { + name: "Flag without query + progressive rollout", + d: dto.DTOv0{ + True: testconvert.Interface("true"), + False: testconvert.Interface("false"), + Default: testconvert.Interface("default"), + Rollout: &dto.RolloutV0{ + Progressive: &dto.ProgressiveV0{ + Percentage: dto.ProgressivePercentageV0{ + Initial: 0, + End: 100, + }, + ReleaseRamp: dto.ProgressiveReleaseRampV0{ + Start: testconvert.Time(time.Date(2021, time.February, 1, 10, 10, 10, 10, time.UTC)), + End: testconvert.Time(time.Date(2021, time.February, 2, 10, 10, 10, 10, time.UTC)), + }, + }, + }, + }, + want: flag.InternalFlag{ + Variations: &map[string]*interface{}{ + "Default": testconvert.Interface("default"), + "False": testconvert.Interface("false"), + "True": testconvert.Interface("true"), + }, + DefaultRule: &flag.Rule{ + Name: testconvert.String("legacyDefaultRule"), + ProgressiveRollout: &flag.ProgressiveRollout{ + Initial: &flag.ProgressiveRolloutStep{ + Variation: testconvert.String("False"), + Percentage: testconvert.Float64(0), + Date: testconvert.Time(time.Date(2021, time.February, 1, 10, 10, 10, 10, time.UTC)), + }, + End: &flag.ProgressiveRolloutStep{ + Variation: testconvert.String("True"), + Percentage: testconvert.Float64(100), + Date: testconvert.Time(time.Date(2021, time.February, 2, 10, 10, 10, 10, time.UTC)), + }, + }, + }, + }, + }, + { + name: "Flag with percentage + scheduled step", + d: dto.DTOv0{ + Percentage: testconvert.Float64(10), + True: testconvert.Interface("true"), + False: testconvert.Interface("false"), + Default: testconvert.Interface("default"), + Rollout: &dto.RolloutV0{ + Scheduled: &dto.ScheduledRolloutV0{Steps: []dto.ScheduledStepV0{ + { + DTOv0: dto.DTOv0{ + Percentage: testconvert.Float64(20), + }, + Date: testconvert.Time(time.Date(2021, time.February, 2, 10, 10, 10, 10, time.UTC)), + }, + { + DTOv0: dto.DTOv0{ + True: testconvert.Interface("true2"), + }, + Date: testconvert.Time(time.Date(2021, time.February, 3, 10, 10, 10, 10, time.UTC)), + }, + { + DTOv0: dto.DTOv0{ + Rule: testconvert.String("key eq \"test-user\""), + }, + Date: testconvert.Time(time.Date(2021, time.February, 4, 10, 10, 10, 10, time.UTC)), + }, + }}, + }, + }, + want: flag.InternalFlag{ + Variations: &map[string]*interface{}{ + "Default": testconvert.Interface("default"), + "False": testconvert.Interface("false"), + "True": testconvert.Interface("true"), + }, + DefaultRule: &flag.Rule{ + Name: testconvert.String("legacyDefaultRule"), + Percentages: &map[string]float64{ + "True": 10, + "False": 90, + }, + }, + Rollout: &flag.Rollout{ + Scheduled: &[]flag.ScheduledStep{ + { + InternalFlag: flag.InternalFlag{ + Variations: &map[string]*interface{}{ + "Default": testconvert.Interface("default"), + "False": testconvert.Interface("false"), + "True": testconvert.Interface("true"), + }, + DefaultRule: &flag.Rule{ + Name: testconvert.String("legacyDefaultRule"), + Percentages: &map[string]float64{ + "False": 80, + "True": 20, + }, + }, + }, + Date: testconvert.Time(time.Date(2021, time.February, 2, 10, 10, 10, 10, time.UTC)), + }, + { + InternalFlag: flag.InternalFlag{ + Variations: &map[string]*interface{}{ + "Default": testconvert.Interface("default"), + "False": testconvert.Interface("false"), + "True": testconvert.Interface("true2"), + }, + DefaultRule: &flag.Rule{ + Name: testconvert.String("legacyDefaultRule"), + Percentages: &map[string]float64{ + "False": 80, + "True": 20, + }, + }, + }, + Date: testconvert.Time(time.Date(2021, time.February, 3, 10, 10, 10, 10, time.UTC)), + }, + { + InternalFlag: flag.InternalFlag{ + Variations: &map[string]*interface{}{ + "Default": testconvert.Interface("default"), + "False": testconvert.Interface("false"), + "True": testconvert.Interface("true2"), + }, + Rules: &[]flag.Rule{ + { + Name: testconvert.String("legacyRuleV0"), + Query: testconvert.String("key eq \"test-user\""), + Percentages: &map[string]float64{ + "False": 80, + "True": 20, + }, + }, + }, + DefaultRule: &flag.Rule{ + Name: testconvert.String("legacyDefaultRule"), + VariationResult: testconvert.String("Default"), + }, + }, + Date: testconvert.Time(time.Date(2021, time.February, 4, 10, 10, 10, 10, time.UTC)), + }, + }, + }, + }, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + assert.Equal(t, tt.want, dto.ConvertV0DtoToInternalFlag(tt.d, false)) + }) + } +} diff --git a/internal/dto/dto.go b/internal/dto/dto.go index dc8c6730983..401d8aae3fd 100644 --- a/internal/dto/dto.go +++ b/internal/dto/dto.go @@ -47,11 +47,11 @@ type DTOv0 struct { Rollout *RolloutV0 `json:"rollout,omitempty" yaml:"rollout,omitempty" toml:"rollout,omitempty"` // Version (optional) This field contains the version of the flag. - // The version is manually managed when you configure your flags and it is used to display the information + // The version is manually managed when you configure your flags and, it is used to display the information // in the notifications and data collection. Version *string `json:"version,omitempty" yaml:"version,omitempty" toml:"version,omitempty"` } func (d *DTO) Convert() flag.InternalFlag { - return ConvertV0DtoToInternalFlag(*d, false) + return ConvertV0DtoToInternalFlag(d.DTOv0, false) } diff --git a/internal/dto/rollout_v0.go b/internal/dto/rollout_v0.go index 195061ae20e..18fbe143ad5 100644 --- a/internal/dto/rollout_v0.go +++ b/internal/dto/rollout_v0.go @@ -10,8 +10,8 @@ type RolloutV0 struct { // Progressive is your struct to configure a progressive rollout deployment of your flag. // It will allow you to ramp up the percentage of your flag over time. - // You can decide at which percentage you starts and at what percentage you ends in your release ramp. - // Before the start date we will serve the initial percentage and after we will serve the end percentage. + // You can decide at which percentage you start and at what percentage you ends in your release ramp. + // Before the start date we will serve the initial percentage and, after we will serve the end percentage. Progressive *ProgressiveV0 `json:"progressive,omitempty" yaml:"progressive,omitempty" toml:"progressive,omitempty"` // nolint: lll // Scheduled is your struct to configure an update on some fields of your flag over time. diff --git a/internal/toremove/toremove.go b/internal/toremove/toremove.go deleted file mode 100644 index 64d14a4346f..00000000000 --- a/internal/toremove/toremove.go +++ /dev/null @@ -1,28 +0,0 @@ -package main - -import ( - "fmt" - - "github.com/thomaspoignant/go-feature-flag/internal/dto" - "github.com/thomaspoignant/go-feature-flag/testutils/testconvert" - "gopkg.in/yaml.v2" -) - -func main() { - t := map[string]dto.DTO{ - "test-flag": { - DTOv0: dto.DTOv0{ - Percentage: testconvert.Float64(5), - True: testconvert.Interface("test"), - False: testconvert.Interface("false"), - Default: testconvert.Interface("default"), - }, - }, - } - - for k, v := range t { - fmt.Println("--- " + k) - y, _ := yaml.Marshal(v.Convert()) - fmt.Println(string(y)) - } -} From ec35950cf476a3e1b71a900e9fcddae38d33e0f0 Mon Sep 17 00:00:00 2001 From: Thomas Poignant Date: Mon, 1 Aug 2022 18:02:31 +0200 Subject: [PATCH 17/50] Add comments Signed-off-by: Thomas Poignant --- internal/dto/converter_v0.go | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/internal/dto/converter_v0.go b/internal/dto/converter_v0.go index b18a2c5f6e0..d67eb904a4c 100644 --- a/internal/dto/converter_v0.go +++ b/internal/dto/converter_v0.go @@ -173,6 +173,9 @@ func convertRollout(dto DTOv0, isScheduledStep bool) *flag.Rollout { scheduledSteps := dto.Rollout.Scheduled.Steps initialDto.Rollout.Scheduled = nil for _, v := range scheduledSteps { + // Hack for simplicity + // When we translate the DTOvO scheduled step into a flag.ScheduledStep what we are doing + // is patching the flag the old way and putting the whole patch into the schedule step. initialDto = mergeDtoScheduledStep(initialDto, v.DTOv0) step := flag.ScheduledStep{ InternalFlag: ConvertV0DtoToInternalFlag(initialDto, false), @@ -182,7 +185,6 @@ func convertRollout(dto DTOv0, isScheduledStep bool) *flag.Rollout { } r.Scheduled = &convertedSteps } - return &r } From 08f46c1449b03069a1fb04abbc21aaeba462593d Mon Sep 17 00:00:00 2001 From: Thomas Poignant Date: Wed, 3 Aug 2022 17:57:17 +0200 Subject: [PATCH 18/50] WIP --- cmd/flagconverter/converter.go | 96 ++++++++++++++++++++++++++ cmd/flagconverter/main.go | 33 +++++++++ go.mod | 1 + go.sum | 2 + internal/dto/converter_v0.go | 78 ++++++--------------- internal/dto/converter_v0_test.go | 38 +++++----- internal/flag/internal_flag_test.go | 69 +++++++++++++++++- internal/flag/rule.go | 14 +++- testdata/flag-config-scheduled-v0.yaml | 27 ++++++++ 9 files changed, 278 insertions(+), 80 deletions(-) create mode 100644 cmd/flagconverter/converter.go create mode 100644 cmd/flagconverter/main.go create mode 100644 testdata/flag-config-scheduled-v0.yaml diff --git a/cmd/flagconverter/converter.go b/cmd/flagconverter/converter.go new file mode 100644 index 00000000000..c10cc260471 --- /dev/null +++ b/cmd/flagconverter/converter.go @@ -0,0 +1,96 @@ +package main + +import ( + "encoding/json" + "fmt" + "io/ioutil" + "strings" + + "github.com/pelletier/go-toml" + "github.com/thomaspoignant/go-feature-flag/internal/dto" + "github.com/thomaspoignant/go-feature-flag/internal/flag" + "gopkg.in/yaml.v3" +) + +// FlagConverter is a cli to convert your old file to a new format +type FlagConverter struct { + InputFile string + InputFormat string + OutputFile string + OutputFormat string +} + +func (f *FlagConverter) Migrate() error { + // Read content of the file + content, err := ioutil.ReadFile(f.InputFile) + if err != nil { + return fmt.Errorf("file %v is impossible to find", f.InputFile) + } + + flags, err := f.marshall(content) + if err != nil { + return err + } + + newFileContent, err := f.unmarshall(f.convert(flags)) + if err != nil { + return err + } + + err = f.output(newFileContent) + if err != nil { + return err + } + + return nil +} + +func (f *FlagConverter) marshall(content []byte) (map[string]dto.DTO, error) { + var flags map[string]dto.DTO + switch strings.ToLower(f.InputFormat) { + case "toml": + err := toml.Unmarshal(content, &flags) + if err != nil { + return nil, err + } + case "json": + err := json.Unmarshal(content, &flags) + if err != nil { + return nil, err + } + default: + err := yaml.Unmarshal(content, &flags) + if err != nil { + return nil, err + } + } + return flags, nil +} + +func (f *FlagConverter) convert(flags map[string]dto.DTO) map[string]flag.InternalFlag { + convertedFlags := make(map[string]flag.InternalFlag, len(flags)) + for k, v := range flags { + convertedFlags[k] = v.Convert() + } + return convertedFlags +} + +func (f *FlagConverter) unmarshall(convertedFlags map[string]flag.InternalFlag) ([]byte, error) { + switch strings.ToLower(f.OutputFormat) { + case "toml": + return toml.Marshal(convertedFlags) + case "json": + return json.Marshal(convertedFlags) + default: + return yaml.Marshal(convertedFlags) + } +} + +func (f *FlagConverter) output(fileContent []byte) error { + if f.OutputFile == "" { + fmt.Println(string(fileContent)) + return nil + } + + return ioutil.WriteFile(f.OutputFile, fileContent, 0o600) +} diff --git a/cmd/flagconverter/main.go b/cmd/flagconverter/main.go new file mode 100644 index 00000000000..36fb8c3ccd6 --- /dev/null +++ b/cmd/flagconverter/main.go @@ -0,0 +1,33 @@ +package main + +import ( + "log" + + "github.com/jessevdk/go-flags" +) + +func main() { + var opts struct { + InputFile string `short:"f" long:"input-file" description:"Location of the flag file you want to convert." required:"true"` //nolint: lll + InputFormat string `long:"input-format" description:"Format of your input file (YAML, JSON or TOML)" required:"false"` //nolint: lll + + OutputFile string `short:"o" long:"output-file" description:"Location of the flag file you want to convert." required:"false"` //nolint: lll + OutputFormat string `long:"output-format" description:"Format of your output file (YAML, JSON or TOML)" required:"false"` //nolint: lll + } + _, err := flags.Parse(&opts) + if err != nil { + log.Fatal("impossible to parse command line parameters", err) + } + + c := FlagConverter{ + InputFile: opts.InputFile, + InputFormat: opts.InputFormat, + OutputFile: opts.OutputFile, + OutputFormat: opts.OutputFormat, + } + + err = c.Migrate() + if err != nil { + log.Fatal(err) + } +} diff --git a/go.mod b/go.mod index a0ff193a06a..922e5d1fc71 100644 --- a/go.mod +++ b/go.mod @@ -8,6 +8,7 @@ require ( github.com/gdexlab/go-render v1.0.1 github.com/golang/mock v1.6.0 github.com/google/go-cmp v0.5.8 + github.com/jessevdk/go-flags v1.5.0 github.com/nikunjy/rules v1.1.0 github.com/pelletier/go-toml v1.9.5 github.com/r3labs/diff/v3 v3.0.0 diff --git a/go.sum b/go.sum index 4488ec3b812..d13b136bb9b 100644 --- a/go.sum +++ b/go.sum @@ -253,6 +253,8 @@ github.com/hpcloud/tail v1.0.0/go.mod h1:ab1qPbhIpdTxEkNHXyeSf5vhxWSCs/tWer42PpO github.com/ianlancetaylor/demangle v0.0.0-20181102032728-5e5cf60278f6/go.mod h1:aSSvb/t6k1mPoxDqO4vJh6VOCGPwU4O0C2/Eqndh1Sc= github.com/ianlancetaylor/demangle v0.0.0-20200824232613-28f6c0f3b639/go.mod h1:aSSvb/t6k1mPoxDqO4vJh6VOCGPwU4O0C2/Eqndh1Sc= github.com/imdario/mergo v0.3.5/go.mod h1:2EnlNZ0deacrJVfApfmtdGgDfMuh/nq6Ok1EcJh5FfA= +github.com/jessevdk/go-flags v1.5.0 h1:1jKYvbxEjfUl0fmqTCOfonvskHHXMjBySTLW4y9LFvc= +github.com/jessevdk/go-flags v1.5.0/go.mod h1:Fw0T6WPc1dYxT4mKEZRfG5kJhaTDP9pj1c2EWnYs/m4= github.com/jmespath/go-jmespath v0.4.0 h1:BEgLn5cpjn8UN1mAw4NjwDrS35OdebyEtFe+9YPoQUg= github.com/jmespath/go-jmespath v0.4.0/go.mod h1:T8mJZnbsbmF+m6zOOFylbeCJqk5+pHWvzYPziyZiYoo= github.com/jmespath/go-jmespath/internal/testify v1.5.1 h1:shLQSRRSCCPj3f2gpwzGwWFoC7ycTf1rcQZHOlsJ6N8= diff --git a/internal/dto/converter_v0.go b/internal/dto/converter_v0.go index d67eb904a4c..390177eb1dd 100644 --- a/internal/dto/converter_v0.go +++ b/internal/dto/converter_v0.go @@ -26,30 +26,31 @@ func ConvertV0DtoToInternalFlag(d DTOv0, isScheduledStep bool) flag.InternalFlag } var rules *[]flag.Rule + var defaultRule *flag.Rule if d.Rule != nil && *d.Rule != "" { - r := make([]flag.Rule, 1) - r[0] = createLegacyRuleV0(d) - rules = &r + rules = &[]flag.Rule{createLegacyRuleV0(d)} + defaultRule = createDefaultLegacyRuleV0(d, true) + } else { + rules = nil + defaultRule = createDefaultLegacyRuleV0(d, false) } - // Default rule - hasTargetRule := rules != nil && len(*rules) > 0 - defaultRule := createDefaultLegacyRuleV0(d, hasTargetRule) - - var rollout *flag.Rollout - if d.Rollout != nil && (d.Rollout.Experimentation != nil || d.Rollout.Scheduled != nil) { - rollout = convertRollout(d, isScheduledStep) - } - - return flag.InternalFlag{ + internalFlag := flag.InternalFlag{ Variations: variations, Rules: rules, DefaultRule: defaultRule, - Rollout: rollout, TrackEvents: d.TrackEvents, Disable: d.Disable, Version: d.Version, } + + var rollout *flag.Rollout + if d.Rollout != nil && (d.Rollout.Experimentation != nil || d.Rollout.Scheduled != nil) { + rollout = convertRollout(d, false) + } + + internalFlag.Rollout = rollout + return internalFlag } // createDefaultLegacyRuleV0 create the default rule based on the legacy format. @@ -76,6 +77,7 @@ func createDefaultLegacyRuleV0(d DTOv0, hasTargetRule bool) *flag.Rule { }, } } + if d.Rule == nil { if d.Percentage == nil { d.Percentage = &defaultPercentage @@ -83,14 +85,16 @@ func createDefaultLegacyRuleV0(d DTOv0, hasTargetRule bool) *flag.Rule { p := computePercentages(*d.Percentage) return &flag.Rule{ - Name: &defaultRuleName, - Percentages: p, + Name: &defaultRuleName, + Percentages: p, + VariationResult: nil, } } return &flag.Rule{ Name: &defaultRuleName, VariationResult: &defaultVariation, + Percentages: nil, } } @@ -169,16 +173,9 @@ func convertRollout(dto DTOv0, isScheduledStep bool) *flag.Rollout { // it is not allowed to have a scheduled step inside a scheduled step if !isScheduledStep && dto.Rollout.Scheduled != nil && dto.Rollout.Scheduled.Steps != nil { var convertedSteps []flag.ScheduledStep - initialDto := dto - scheduledSteps := dto.Rollout.Scheduled.Steps - initialDto.Rollout.Scheduled = nil - for _, v := range scheduledSteps { - // Hack for simplicity - // When we translate the DTOvO scheduled step into a flag.ScheduledStep what we are doing - // is patching the flag the old way and putting the whole patch into the schedule step. - initialDto = mergeDtoScheduledStep(initialDto, v.DTOv0) + for _, v := range dto.Rollout.Scheduled.Steps { step := flag.ScheduledStep{ - InternalFlag: ConvertV0DtoToInternalFlag(initialDto, false), + InternalFlag: ConvertV0DtoToInternalFlag(v.DTOv0, true), Date: v.Date, } convertedSteps = append(convertedSteps, step) @@ -196,34 +193,3 @@ func computePercentages(percentage float64) *map[string]float64 { falseVariation: 100 - percentage, } } - -func mergeDtoScheduledStep(origin DTOv0, toBeMerged DTOv0) DTOv0 { - if toBeMerged.Disable != nil { - origin.Disable = toBeMerged.Disable - } - if toBeMerged.False != nil { - origin.False = toBeMerged.False - } - if toBeMerged.True != nil { - origin.True = toBeMerged.True - } - if toBeMerged.Default != nil { - origin.Default = toBeMerged.Default - } - if toBeMerged.TrackEvents != nil { - origin.TrackEvents = toBeMerged.TrackEvents - } - if toBeMerged.Percentage != nil { - origin.Percentage = toBeMerged.Percentage - } - if toBeMerged.Rule != nil { - origin.Rule = toBeMerged.Rule - } - if toBeMerged.Rollout != nil { - origin.Rollout = toBeMerged.Rollout - } - if toBeMerged.Version != nil { - origin.Version = toBeMerged.Version - } - return origin -} diff --git a/internal/dto/converter_v0_test.go b/internal/dto/converter_v0_test.go index 59f47f0ea57..5c0e0767352 100644 --- a/internal/dto/converter_v0_test.go +++ b/internal/dto/converter_v0_test.go @@ -1,6 +1,8 @@ package dto_test import ( + "encoding/json" + "fmt" "testing" "time" @@ -322,18 +324,18 @@ func TestConvertV0DtoToInternalFlag(t *testing.T) { Default: testconvert.Interface("default"), Rollout: &dto.RolloutV0{ Scheduled: &dto.ScheduledRolloutV0{Steps: []dto.ScheduledStepV0{ - { - DTOv0: dto.DTOv0{ - Percentage: testconvert.Float64(20), - }, - Date: testconvert.Time(time.Date(2021, time.February, 2, 10, 10, 10, 10, time.UTC)), - }, - { - DTOv0: dto.DTOv0{ - True: testconvert.Interface("true2"), - }, - Date: testconvert.Time(time.Date(2021, time.February, 3, 10, 10, 10, 10, time.UTC)), - }, + //{ + // DTOv0: dto.DTOv0{ + // Percentage: testconvert.Float64(20), + // }, + // Date: testconvert.Time(time.Date(2021, time.February, 2, 10, 10, 10, 10, time.UTC)), + // }, + //{ + // DTOv0: dto.DTOv0{ + // True: testconvert.Interface("true2"), + // }, + // Date: testconvert.Time(time.Date(2021, time.February, 3, 10, 10, 10, 10, time.UTC)), + // }, { DTOv0: dto.DTOv0{ Rule: testconvert.String("key eq \"test-user\""), @@ -360,11 +362,6 @@ func TestConvertV0DtoToInternalFlag(t *testing.T) { Scheduled: &[]flag.ScheduledStep{ { InternalFlag: flag.InternalFlag{ - Variations: &map[string]*interface{}{ - "Default": testconvert.Interface("default"), - "False": testconvert.Interface("false"), - "True": testconvert.Interface("true"), - }, DefaultRule: &flag.Rule{ Name: testconvert.String("legacyDefaultRule"), Percentages: &map[string]float64{ @@ -403,10 +400,6 @@ func TestConvertV0DtoToInternalFlag(t *testing.T) { { Name: testconvert.String("legacyRuleV0"), Query: testconvert.String("key eq \"test-user\""), - Percentages: &map[string]float64{ - "False": 80, - "True": 20, - }, }, }, DefaultRule: &flag.Rule{ @@ -423,6 +416,9 @@ func TestConvertV0DtoToInternalFlag(t *testing.T) { } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { + res := dto.ConvertV0DtoToInternalFlag(tt.d, false) + m, _ := json.Marshal(res) + fmt.Println(string(m)) assert.Equal(t, tt.want, dto.ConvertV0DtoToInternalFlag(tt.d, false)) }) } diff --git a/internal/flag/internal_flag_test.go b/internal/flag/internal_flag_test.go index 68f4aed7e19..4bc84051ef8 100644 --- a/internal/flag/internal_flag_test.go +++ b/internal/flag/internal_flag_test.go @@ -48,6 +48,31 @@ func TestInternalFlag_Value(t *testing.T) { Reason: flag.ReasonDefault, }, }, + { + name: "Should use default value if percentages are empty", + flag: flag.InternalFlag{ + Variations: &map[string]*interface{}{ + "variation_A": testconvert.Interface(true), + "variation_B": testconvert.Interface(false), + }, + DefaultRule: &flag.Rule{ + VariationResult: testconvert.String("variation_A"), + Percentages: &map[string]float64{}, + }, + }, + args: args{ + flagName: "my-flag", + user: ffuser.NewUser("user-key"), + evaluationCtx: flag.EvaluationContext{ + DefaultSdkValue: false, + }, + }, + want: true, + want1: flag.ResolutionDetails{ + Variant: "variation_A", + Reason: flag.ReasonDefault, + }, + }, { name: "Should return sdk default value when flag is disabled", flag: flag.InternalFlag{ @@ -221,7 +246,7 @@ func TestInternalFlag_Value(t *testing.T) { }, }, { - name: "Should match only the first rule that apply (even if more than one can apply)å", + name: "Should match only the first rule that apply (even if more than one can apply)", flag: flag.InternalFlag{ Variations: &map[string]*interface{}{ "variation_A": testconvert.Interface("value_A"), @@ -261,6 +286,48 @@ func TestInternalFlag_Value(t *testing.T) { RuleIndex: testconvert.Int(1), }, }, + { + name: "Should ignore a rule that is disabled", + flag: flag.InternalFlag{ + Variations: &map[string]*interface{}{ + "variation_A": testconvert.Interface("value_A"), + "variation_B": testconvert.Interface("value_B"), + "variation_C": testconvert.Interface("value_C"), + "variation_D": testconvert.Interface("value_D"), + }, + Rules: &[]flag.Rule{ + { + Query: testconvert.String("key eq \"not-user-key\""), + VariationResult: testconvert.String("variation_C"), + }, + { + Query: testconvert.String("company eq \"go-feature-flag\""), + VariationResult: testconvert.String("variation_D"), + Disable: testconvert.Bool(true), + }, + { + Query: testconvert.String("key eq \"user-key\""), + VariationResult: testconvert.String("variation_C"), + }, + }, + DefaultRule: &flag.Rule{ + VariationResult: testconvert.String("variation_A"), + }, + }, + args: args{ + flagName: "my-flag", + user: ffuser.NewUserBuilder("user-key").AddCustom("company", "go-feature-flag").Build(), + evaluationCtx: flag.EvaluationContext{ + DefaultSdkValue: "value_default", + }, + }, + want: "value_C", + want1: flag.ResolutionDetails{ + Variant: "variation_C", + Reason: flag.ReasonTargetingMatch, + RuleIndex: testconvert.Int(2), + }, + }, { name: "Should return an error if rule is invalid", flag: flag.InternalFlag{ diff --git a/internal/flag/rule.go b/internal/flag/rule.go index a44b5d7049c..0ba7da38d9e 100644 --- a/internal/flag/rule.go +++ b/internal/flag/rule.go @@ -34,6 +34,9 @@ type Rule struct { // You can decide at which percentage you starts with and at what percentage you ends with in your release ramp. // Before the start date we will serve the initial percentage and, after we will serve the end percentage. ProgressiveRollout *ProgressiveRollout `json:"progressiveRollout,omitempty" yaml:"progressiveRollout,omitempty" toml:"progressiveRollout,omitempty"` // nolint: lll + + // Disable indicates that this rule is disabled. + Disable *bool `json:"disable,omitempty" yaml:"disable,omitempty" toml:"disable,omitempty"` } // Evaluate is checking if the originalRule apply to for the user. @@ -42,7 +45,7 @@ func (r *Rule) Evaluate(user ffuser.User, hashID uint32, isDefault bool, ) (string, error) { // Check if the originalRule apply for this user ruleApply := isDefault || r.GetQuery() == "" || parser.Evaluate(r.GetQuery(), utils.UserToMap(user)) - if !ruleApply { + if !ruleApply || r.IsDisable() { return "", &internalerror.RuleNotApply{User: user} } @@ -54,7 +57,7 @@ func (r *Rule) Evaluate(user ffuser.User, hashID uint32, isDefault bool, return variation, nil } - if r.Percentages != nil { + if r.Percentages != nil && len(r.GetPercentages()) > 0 { variationName, err := r.getVariationFromPercentage(hashID) if err != nil { return "", err @@ -228,6 +231,13 @@ func (r *Rule) GetPercentages() map[string]float64 { return *r.Percentages } +func (r *Rule) IsDisable() bool { + if r.Disable == nil { + return false + } + return *r.Disable +} + func (r *Rule) GetProgressiveRollout() ProgressiveRollout { if r.ProgressiveRollout == nil { return ProgressiveRollout{ diff --git a/testdata/flag-config-scheduled-v0.yaml b/testdata/flag-config-scheduled-v0.yaml new file mode 100644 index 00000000000..111f405cb9e --- /dev/null +++ b/testdata/flag-config-scheduled-v0.yaml @@ -0,0 +1,27 @@ +test-flag: + rule: key eq "random-key" + percentage: 100 + true: true + false: false + default: false + rollout: + scheduled: + steps: + - date: 2022-08-01T00:00:00.10+02:00 + rule: beta eq "true" + percentage: 100 + + - date: 2022-05-12T15:36:00.10+02:00 + rule: beta eq "false" + percentage: 0 + + - date: 2022-05-12T15:36:00.10+02:00 + rule: "" + + +test-flag2: + rule: key eq "not-a-key" + percentage: 100 + true: true + false: false + default: false From 145df105bc4f2cf7464e71776b00a1d843077811 Mon Sep 17 00:00:00 2001 From: Thomas Poignant Date: Sun, 7 Aug 2022 21:20:12 +0200 Subject: [PATCH 19/50] WIP Signed-off-by: Thomas Poignant --- internal/dto/converter_v0.go | 180 +++++++++++++- internal/dto/converter_v0_test.go | 312 ++++++++++++++++++++++- internal/dto/toremove_test.go | 107 ++++++++ internal/flag/internal_flag.go | 9 + internal/flag/rule.go | 2 +- testutils/flagv1/convert.go | 63 +++++ testutils/flagv1/flag_data.go | 386 +++++++++++++++++++++++++++++ testutils/flagv1/rollout.go | 97 ++++++++ testutils/flagv1/variation_type.go | 12 + 9 files changed, 1158 insertions(+), 10 deletions(-) create mode 100644 internal/dto/toremove_test.go create mode 100644 testutils/flagv1/convert.go create mode 100644 testutils/flagv1/flag_data.go create mode 100644 testutils/flagv1/rollout.go create mode 100644 testutils/flagv1/variation_type.go diff --git a/internal/dto/converter_v0.go b/internal/dto/converter_v0.go index 390177eb1dd..dd19b183c98 100644 --- a/internal/dto/converter_v0.go +++ b/internal/dto/converter_v0.go @@ -1,7 +1,9 @@ package dto import ( + "fmt" "github.com/thomaspoignant/go-feature-flag/internal/flag" + "github.com/thomaspoignant/go-feature-flag/testutils/testconvert" ) var ( @@ -12,6 +14,10 @@ var ( falseVariation = "False" defaultVariation = "Default" defaultPercentage = float64(0) + + emptyVarRes = "" + disableRuleValue = true + enableRuleValue = false ) // ConvertV0DtoToInternalFlag is converting a flag in the config file to the internal format. @@ -46,7 +52,7 @@ func ConvertV0DtoToInternalFlag(d DTOv0, isScheduledStep bool) flag.InternalFlag var rollout *flag.Rollout if d.Rollout != nil && (d.Rollout.Experimentation != nil || d.Rollout.Scheduled != nil) { - rollout = convertRollout(d, false) + rollout = convertRollout(d, internalFlag) } internalFlag.Rollout = rollout @@ -159,7 +165,160 @@ func createVariationsV0(d DTOv0, isScheduleStep bool) map[string]*interface{} { return variations } -func convertRollout(dto DTOv0, isScheduledStep bool) *flag.Rollout { +func createScheduledStep(f flag.InternalFlag, dto ScheduledStepV0) flag.ScheduledStep { + step := flag.ScheduledStep{ + Date: dto.Date, + } + + variations := createVariationsV0(dto.DTOv0, true) + step.Variations = &variations + + ruleIndex := f.GetRuleIndexByName(LegacyRuleName) + hasRuleBefore := ruleIndex != nil && !f.GetRules()[*ruleIndex].IsDisable() + updateRule := dto.Rule != nil + + // rules management + switch { + + case hasRuleBefore && !updateRule: + // deactivate rule + update the default rule + // activate the target rule + if dto.Percentage != nil { + step.Rules = &[]flag.Rule{{ + Name: testconvert.String(LegacyRuleName), + Percentages: computePercentages(*dto.Percentage), + }} + } + fmt.Println("1") + break + + case !hasRuleBefore && updateRule: + if *dto.Rule == "" { + // disable target + update default + step.Rules = &[]flag.Rule{{ + Name: testconvert.String(LegacyRuleName), + Disable: &disableRuleValue, + }} + + step.DefaultRule = &flag.Rule{ + Name: testconvert.String(defaultRuleName), + } + + if dto.Percentage != nil { + step.DefaultRule.Percentages = computePercentages(*dto.Percentage) + } + } else { + // TODO: Update target + } + fmt.Println("2") + break + + case !hasRuleBefore && !updateRule: + //update the defaultRule + if dto.Percentage != nil { + step.DefaultRule = &flag.Rule{ + VariationResult: &emptyVarRes, + Name: testconvert.String(defaultRuleName), + Percentages: computePercentages(*dto.Percentage), + } + } + fmt.Println("3") + break + + case hasRuleBefore && updateRule: + // update targeting + if dto.Rule != nil { + r := flag.Rule{ + Name: testconvert.String(LegacyRuleName), + Query: dto.Rule, + Disable: &enableRuleValue, + } + if dto.Percentage != nil { + r.VariationResult = &emptyVarRes + r.Percentages = computePercentages(*dto.Percentage) + } + step.Rules = &[]flag.Rule{r} + } else { + // TODO: disable targeting and update default + } + fmt.Println("4") + break + } + + // we have only a default rule + //if dto.Rule == nil && ruleIndex == nil { + // if dto.Percentage != nil { + // step.DefaultRule = &flag.Rule{ + // Name: &defaultRuleName, + // Percentages: computePercentages(*dto.Percentage), + // } + // } + //} + // + //if dto.Rule != nil && *dto.Rule == "" && ruleIndex != nil { + // disable := true + // r := flag.Rule{ + // Name: testconvert.String(LegacyRuleName), + // Disable: &disable, + // } + // step.Rules = &[]flag.Rule{r} + //} + // + //// We add a rule before or we update the query + //if dto.Rule != nil || (ruleIndex != nil && !f.GetRules()[*ruleIndex].IsDisable()) { + // r := flag.Rule{ + // Name: testconvert.String(LegacyRuleName), + // Query: dto.Rule, + // } + // + // if dto.Percentage != nil { + // if ruleIndex != nil && f.GetRules()[*ruleIndex].VariationResult != nil { + // r.VariationResult = testconvert.String("") + // } + // r.Percentages = computePercentages(*dto.Percentage) + // } else if ruleIndex != nil && f.GetRules()[*ruleIndex].Percentages != nil { + // r.Percentages = deepCopyPercentages(f.GetRules()[*ruleIndex].GetPercentages()) + // } else if ruleIndex == nil && f.GetDefaultRule() != nil { + // r.Percentages = deepCopyPercentages(f.GetDefaultRule().GetPercentages()) + // } + // + // // if we did not have rules before we migrate the percentage into the rule + // if ruleIndex == nil && dto.Percentage == nil { + // r.Percentages = deepCopyPercentages(f.GetDefaultRule().GetPercentages()) + // } + // + // // remove all percentages from default rule + // if f.GetDefaultRule().Percentages != nil { + // removedPercentages := map[string]float64{} + // for k, _ := range f.GetDefaultRule().GetPercentages() { + // removedPercentages[k] = -1 + // } + // step.DefaultRule = &flag.Rule{ + // Percentages: &removedPercentages, + // Name: &defaultRuleName, + // VariationResult: &defaultVariation, + // } + // } + // + // step.Rules = &[]flag.Rule{r} + //} + + if dto.Disable != nil { + step.Disable = dto.Disable + } + + if dto.TrackEvents != nil { + step.TrackEvents = dto.TrackEvents + } + + if dto.Version != nil { + step.Version = dto.Version + } + + return step +} + +func convertRollout(dto DTOv0, f flag.InternalFlag) *flag.Rollout { r := flag.Rollout{} if dto.Rollout.Experimentation != nil && dto.Rollout.Experimentation.Start != nil && @@ -171,14 +330,10 @@ func convertRollout(dto DTOv0, isScheduledStep bool) *flag.Rollout { } // it is not allowed to have a scheduled step inside a scheduled step - if !isScheduledStep && dto.Rollout.Scheduled != nil && dto.Rollout.Scheduled.Steps != nil { + if dto.Rollout.Scheduled != nil && dto.Rollout.Scheduled.Steps != nil { var convertedSteps []flag.ScheduledStep for _, v := range dto.Rollout.Scheduled.Steps { - step := flag.ScheduledStep{ - InternalFlag: ConvertV0DtoToInternalFlag(v.DTOv0, true), - Date: v.Date, - } - convertedSteps = append(convertedSteps, step) + convertedSteps = append(convertedSteps, createScheduledStep(f, v)) } r.Scheduled = &convertedSteps } @@ -193,3 +348,12 @@ func computePercentages(percentage float64) *map[string]float64 { falseVariation: 100 - percentage, } } + +func deepCopyPercentages(in map[string]float64) *map[string]float64 { + p := make(map[string]float64, len(in)) + // deep copy of the percentages to avoid being override + for k, v := range in { + p[k] = v + } + return &p +} diff --git a/internal/dto/converter_v0_test.go b/internal/dto/converter_v0_test.go index 5c0e0767352..9caf2fa4cb2 100644 --- a/internal/dto/converter_v0_test.go +++ b/internal/dto/converter_v0_test.go @@ -3,6 +3,8 @@ package dto_test import ( "encoding/json" "fmt" + "github.com/thomaspoignant/go-feature-flag/ffuser" + "github.com/thomaspoignant/go-feature-flag/testutils/flagv1" "testing" "time" @@ -324,7 +326,7 @@ func TestConvertV0DtoToInternalFlag(t *testing.T) { Default: testconvert.Interface("default"), Rollout: &dto.RolloutV0{ Scheduled: &dto.ScheduledRolloutV0{Steps: []dto.ScheduledStepV0{ - //{ + //{ScheduledStepV0 // DTOv0: dto.DTOv0{ // Percentage: testconvert.Float64(20), // }, @@ -423,3 +425,311 @@ func TestConvertV0DtoToInternalFlag(t *testing.T) { }) } } + +func TestConvertV0ScheduleStep(t *testing.T) { + tests := []struct { + name string + dto dto.DTO + }{ + { + name: "Update a rule that exists already", + dto: dto.DTO{ + DTOv0: dto.DTOv0{ + Rule: testconvert.String("key eq \"yo\""), + True: testconvert.Interface("true"), + False: testconvert.Interface("false"), + Default: testconvert.Interface("default"), + Percentage: testconvert.Float64(95), + Rollout: &dto.RolloutV0{ + Scheduled: &dto.ScheduledRolloutV0{Steps: []dto.ScheduledStepV0{ + { + DTOv0: dto.DTOv0{ + Rule: testconvert.String("anonymous eq false"), + }, + Date: testconvert.Time(time.Now().Add(-2 * time.Second)), + }, + }}, + }, + }, + }, + }, + { + name: "Update a rule that exists already + percentages", + dto: dto.DTO{ + DTOv0: dto.DTOv0{ + Rule: testconvert.String("key eq \"yo\""), + True: testconvert.Interface("true"), + False: testconvert.Interface("false"), + Default: testconvert.Interface("default"), + Percentage: testconvert.Float64(95), + Rollout: &dto.RolloutV0{ + Scheduled: &dto.ScheduledRolloutV0{Steps: []dto.ScheduledStepV0{ + { + DTOv0: dto.DTOv0{ + Rule: testconvert.String("anonymous eq false"), + Percentage: testconvert.Float64(5), + }, + Date: testconvert.Time(time.Now().Add(-2 * time.Second)), + }, + }}, + }, + }, + }, + }, + { + name: "No rule, update only percentages", + dto: dto.DTO{ + DTOv0: dto.DTOv0{ + True: testconvert.Interface("true"), + False: testconvert.Interface("false"), + Default: testconvert.Interface("default"), + Percentage: testconvert.Float64(100), + Rollout: &dto.RolloutV0{ + Scheduled: &dto.ScheduledRolloutV0{Steps: []dto.ScheduledStepV0{ + { + DTOv0: dto.DTOv0{ + Percentage: testconvert.Float64(10), + }, + Date: testconvert.Time(time.Now().Add(-2 * time.Second)), + }, + }}, + }, + }, + }, + }, + { + name: "No rule, add rule which not match", + dto: dto.DTO{ + DTOv0: dto.DTOv0{ + True: testconvert.Interface("true"), + False: testconvert.Interface("false"), + Default: testconvert.Interface("default"), + Percentage: testconvert.Float64(100), + Rollout: &dto.RolloutV0{ + Scheduled: &dto.ScheduledRolloutV0{Steps: []dto.ScheduledStepV0{ + { + DTOv0: dto.DTOv0{ + Rule: testconvert.String("key eq \"ko\""), + }, + Date: testconvert.Time(time.Now().Add(-2 * time.Second)), + }, + }}, + }, + }, + }, + }, + { + name: "No rule, add rule which match", + dto: dto.DTO{ + DTOv0: dto.DTOv0{ + True: testconvert.Interface("true"), + False: testconvert.Interface("false"), + Default: testconvert.Interface("default"), + Percentage: testconvert.Float64(100), + Rollout: &dto.RolloutV0{ + Scheduled: &dto.ScheduledRolloutV0{Steps: []dto.ScheduledStepV0{ + { + DTOv0: dto.DTOv0{ + Rule: testconvert.String("key eq \"yo\""), + }, + Date: testconvert.Time(time.Now().Add(-2 * time.Second)), + }, + }}, + }, + }, + }, + }, + { + name: "Change value of a variation", + dto: dto.DTO{ + DTOv0: dto.DTOv0{ + True: testconvert.Interface("true"), + False: testconvert.Interface("false"), + Default: testconvert.Interface("default"), + Percentage: testconvert.Float64(100), + Rollout: &dto.RolloutV0{ + Scheduled: &dto.ScheduledRolloutV0{Steps: []dto.ScheduledStepV0{ + { + DTOv0: dto.DTOv0{ + True: testconvert.Interface("newValue"), + }, + Date: testconvert.Time(time.Now().Add(-2 * time.Second)), + }, + }}, + }, + }, + }, + }, + { + name: "Change percentage with no rule", + dto: dto.DTO{ + DTOv0: dto.DTOv0{ + True: testconvert.Interface("true"), + False: testconvert.Interface("false"), + Default: testconvert.Interface("default"), + Percentage: testconvert.Float64(100), + Rollout: &dto.RolloutV0{ + Scheduled: &dto.ScheduledRolloutV0{Steps: []dto.ScheduledStepV0{ + { + DTOv0: dto.DTOv0{ + Percentage: testconvert.Float64(10), + }, + Date: testconvert.Time(time.Now().Add(-2 * time.Second)), + }, + }}, + }, + }, + }, + }, + { + name: "Change percentage and add rule (not in percentage)", + dto: dto.DTO{ + DTOv0: dto.DTOv0{ + True: testconvert.Interface("true"), + False: testconvert.Interface("false"), + Default: testconvert.Interface("default"), + Percentage: testconvert.Float64(100), + Rollout: &dto.RolloutV0{ + Scheduled: &dto.ScheduledRolloutV0{Steps: []dto.ScheduledStepV0{ + { + DTOv0: dto.DTOv0{ + Rule: testconvert.String("key eq \"yo\""), + Percentage: testconvert.Float64(10), + }, + Date: testconvert.Time(time.Now().Add(-2 * time.Second)), + }, + }}, + }, + }, + }, + }, + { + name: "Change percentage and add rule (in percentage)", + dto: dto.DTO{ + DTOv0: dto.DTOv0{ + True: testconvert.Interface("true"), + False: testconvert.Interface("false"), + Default: testconvert.Interface("default"), + Percentage: testconvert.Float64(100), + Rollout: &dto.RolloutV0{ + Scheduled: &dto.ScheduledRolloutV0{Steps: []dto.ScheduledStepV0{ + { + DTOv0: dto.DTOv0{ + Rule: testconvert.String("key eq \"yo\""), + Percentage: testconvert.Float64(50), + }, + Date: testconvert.Time(time.Now().Add(-2 * time.Second)), + }, + }}, + }, + }, + }, + }, + { + name: "Add rule and remove rule + change percentages", + dto: dto.DTO{ + DTOv0: dto.DTOv0{ + True: testconvert.Interface("true"), + False: testconvert.Interface("false"), + Default: testconvert.Interface("default"), + Rule: testconvert.String("key eq \"yo\""), + Percentage: testconvert.Float64(100), + Rollout: &dto.RolloutV0{ + Scheduled: &dto.ScheduledRolloutV0{Steps: []dto.ScheduledStepV0{ + { + DTOv0: dto.DTOv0{ + Rule: testconvert.String("key eq \"yo\""), + }, + Date: testconvert.Time(time.Now().Add(-2 * time.Second)), + }, + { + DTOv0: dto.DTOv0{ + Rule: testconvert.String(""), + }, + Date: testconvert.Time(time.Now().Add(-2 * time.Second)), + }, + { + DTOv0: dto.DTOv0{ + Percentage: testconvert.Float64(10), + }, + Date: testconvert.Time(time.Now().Add(-2 * time.Second)), + }, + }}, + }, + }, + }, + }, + { + name: "Rule with percentages, remove rule", + dto: dto.DTO{ + DTOv0: dto.DTOv0{ + True: testconvert.Interface("true"), + False: testconvert.Interface("false"), + Default: testconvert.Interface("default"), + Rule: testconvert.String("key eq \"yo\""), + Percentage: testconvert.Float64(95), + Rollout: &dto.RolloutV0{ + Scheduled: &dto.ScheduledRolloutV0{Steps: []dto.ScheduledStepV0{ + { + DTOv0: dto.DTOv0{ + Rule: testconvert.String(""), + }, + Date: testconvert.Time(time.Now().Add(-2 * time.Second)), + }, + }}, + }, + }, + }, + }, + { + name: "XXX", + dto: dto.DTO{ + DTOv0: dto.DTOv0{ + True: testconvert.Interface("true"), + False: testconvert.Interface("false"), + Default: testconvert.Interface("default"), + Rule: testconvert.String("key eq \"yo\""), + Percentage: testconvert.Float64(100), + Rollout: &dto.RolloutV0{ + Scheduled: &dto.ScheduledRolloutV0{Steps: []dto.ScheduledStepV0{ + { + DTOv0: dto.DTOv0{ + Rule: testconvert.String("key eq \"oy\""), + }, + Date: testconvert.Time(time.Now().Add(-2 * time.Second)), + }, + { + DTOv0: dto.DTOv0{ + Percentage: testconvert.Float64(95), + }, + Date: testconvert.Time(time.Now().Add(-2 * time.Second)), + }, + { + DTOv0: dto.DTOv0{ + Rule: testconvert.String("key eq \"yo\""), + }, + Date: testconvert.Time(time.Now().Add(-2 * time.Second)), + }, + }}, + }, + }, + }, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + u := ffuser.NewUser("yo") + flagName := "yo" + + convertInternalFlag := tt.dto.Convert() + gotInternalFlag, _ := convertInternalFlag.Value(flagName, u, flag.EvaluationContext{}) + + convertFlagv1 := flagv1.ConvertDtoToV1(tt.dto.DTOv0) + gotFlagV1, _ := convertFlagv1.Value(flagName, u, flag.EvaluationContext{}) + + fmt.Println(gotFlagV1, gotInternalFlag) + assert.Equal(t, gotFlagV1, gotInternalFlag) + }) + } + +} diff --git a/internal/dto/toremove_test.go b/internal/dto/toremove_test.go new file mode 100644 index 00000000000..e7b47c8a659 --- /dev/null +++ b/internal/dto/toremove_test.go @@ -0,0 +1,107 @@ +package dto_test + +import ( + "fmt" + "github.com/stretchr/testify/assert" + "github.com/thomaspoignant/go-feature-flag/ffuser" + "github.com/thomaspoignant/go-feature-flag/internal/dto" + "github.com/thomaspoignant/go-feature-flag/internal/flag" + "github.com/thomaspoignant/go-feature-flag/testutils/flagv1" + "github.com/thomaspoignant/go-feature-flag/testutils/testconvert" + "testing" + "time" +) + +func Test_toto(t *testing.T) { + u := ffuser.NewUser("yo") + flagName := "yo" + d := dto.DTO{ + DTOv0: dto.DTOv0{ + True: testconvert.Interface("true"), + False: testconvert.Interface("false"), + Default: testconvert.Interface("default"), + Percentage: testconvert.Float64(100), + Rollout: &dto.RolloutV0{ + Scheduled: &dto.ScheduledRolloutV0{Steps: []dto.ScheduledStepV0{ + { + DTOv0: dto.DTOv0{ + Percentage: testconvert.Float64(10), + }, + Date: testconvert.Time(time.Now().Add(-2 * time.Second)), + }, + { + DTOv0: dto.DTOv0{ + Rule: testconvert.String("key eq \"yo\""), + }, + Date: testconvert.Time(time.Now().Add(-2 * time.Second)), + }, + { + DTOv0: dto.DTOv0{ + True: testconvert.Interface("newValue"), + }, + Date: testconvert.Time(time.Now().Add(-2 * time.Second)), + }, + { + DTOv0: dto.DTOv0{ + Percentage: testconvert.Float64(10), + }, + Date: testconvert.Time(time.Now().Add(-2 * time.Second)), + }, + { + DTOv0: dto.DTOv0{ + Rule: testconvert.String(""), + Percentage: testconvert.Float64(100), + }, + Date: testconvert.Time(time.Now().Add(-2 * time.Second)), + }, + { + DTOv0: dto.DTOv0{ + Disable: testconvert.Bool(true), + }, + Date: testconvert.Time(time.Now().Add(-2 * time.Second)), + }, + { + DTOv0: dto.DTOv0{ + Disable: testconvert.Bool(false), + Rule: testconvert.String("anonymous eq false"), + Percentage: testconvert.Float64(100), + }, + Date: testconvert.Time(time.Now().Add(-2 * time.Second)), + }, + { + DTOv0: dto.DTOv0{ + Rollout: &dto.RolloutV0{ + Experimentation: &dto.ExperimentationV0{ + Start: testconvert.Time(time.Now().Add(-2 * time.Second)), + End: testconvert.Time(time.Now().Add(2 * time.Second)), + }, + }, + }, + Date: testconvert.Time(time.Now().Add(-2 * time.Second)), + }, + { + DTOv0: dto.DTOv0{ + Rollout: &dto.RolloutV0{ + Experimentation: &dto.ExperimentationV0{ + End: testconvert.Time(time.Now().Add(-2 * time.Second)), + }, + }, + }, + Date: testconvert.Time(time.Now().Add(-2 * time.Second)), + }, + }}, + }, + }, + } + + c := d.Convert() + n, _ := c.Value(flagName, u, flag.EvaluationContext{}) + + e := flagv1.ConvertDtoToV1(d.DTOv0) + m, _ := e.Value(flagName, u, flag.EvaluationContext{}) + + fmt.Println(m) + assert.Equal(t, m, n) + //assert.Equal(t, n1, m1) + +} diff --git a/internal/flag/internal_flag.go b/internal/flag/internal_flag.go index d513e46cea9..e099fa0b44f 100644 --- a/internal/flag/internal_flag.go +++ b/internal/flag/internal_flag.go @@ -188,6 +188,15 @@ func (f *InternalFlag) GetRules() []Rule { return *f.Rules } +func (f *InternalFlag) GetRuleIndexByName(name string) *int { + for index, rule := range f.GetRules() { + if rule.GetName() == name { + return &index + } + } + return nil +} + // GetDefaultRule is the getter of the field DefaultRule func (f *InternalFlag) GetDefaultRule() *Rule { return f.DefaultRule diff --git a/internal/flag/rule.go b/internal/flag/rule.go index 0ba7da38d9e..4a73e3ba842 100644 --- a/internal/flag/rule.go +++ b/internal/flag/rule.go @@ -45,7 +45,7 @@ func (r *Rule) Evaluate(user ffuser.User, hashID uint32, isDefault bool, ) (string, error) { // Check if the originalRule apply for this user ruleApply := isDefault || r.GetQuery() == "" || parser.Evaluate(r.GetQuery(), utils.UserToMap(user)) - if !ruleApply || r.IsDisable() { + if !ruleApply || (!isDefault && r.IsDisable()) { return "", &internalerror.RuleNotApply{User: user} } diff --git a/testutils/flagv1/convert.go b/testutils/flagv1/convert.go new file mode 100644 index 00000000000..1ef2991e527 --- /dev/null +++ b/testutils/flagv1/convert.go @@ -0,0 +1,63 @@ +package flagv1 + +import "github.com/thomaspoignant/go-feature-flag/internal/dto" + +func ConvertDtoToV1(d dto.DTOv0) FlagData { + var r Rollout + + if d.Rollout != nil { + r = Rollout{} + + if d.Rollout.Progressive != nil { + r.Progressive = &Progressive{} + r.Progressive.ReleaseRamp.Start = d.Rollout.Progressive.ReleaseRamp.Start + r.Progressive.ReleaseRamp.End = d.Rollout.Progressive.ReleaseRamp.End + r.Progressive.Percentage.End = d.Rollout.Progressive.Percentage.End + r.Progressive.Percentage.Initial = d.Rollout.Progressive.Percentage.Initial + } + + if d.Rollout.Scheduled != nil { + r.Scheduled = &ScheduledRollout{} + if d.Rollout.Scheduled.Steps != nil { + r.Scheduled.Steps = []ScheduledStep{} + for _, step := range d.Rollout.Scheduled.Steps { + s := ScheduledStep{ + FlagData: FlagData{ + Rule: step.Rule, + Percentage: step.Percentage, + True: step.True, + False: step.False, + Default: step.Default, + TrackEvents: step.TrackEvents, + Disable: step.Disable, + }, + Date: step.Date, + } + r.Scheduled.Steps = append(r.Scheduled.Steps, s) + } + } + } + + if d.Rollout.Experimentation != nil { + r.Experimentation = &Experimentation{} + if d.Rollout.Experimentation.Start != nil { + r.Experimentation.Start = d.Rollout.Experimentation.Start + } + if d.Rollout.Experimentation.End != nil { + r.Experimentation.End = d.Rollout.Experimentation.End + } + } + } + + return FlagData{ + Rule: d.Rule, + Percentage: d.Percentage, + True: d.True, + False: d.False, + Default: d.Default, + TrackEvents: d.TrackEvents, + Disable: d.Disable, + Rollout: &r, + } + +} diff --git a/testutils/flagv1/flag_data.go b/testutils/flagv1/flag_data.go new file mode 100644 index 00000000000..83f43ec9543 --- /dev/null +++ b/testutils/flagv1/flag_data.go @@ -0,0 +1,386 @@ +package flagv1 + +import ( + "fmt" + "math" + "strconv" + "strings" + "time" + + "github.com/thomaspoignant/go-feature-flag/internal/flag" + + "github.com/nikunjy/rules/parser" + "github.com/thomaspoignant/go-feature-flag/ffuser" + "github.com/thomaspoignant/go-feature-flag/internal/utils" +) + +// percentageMultiplier is the multiplier used to have a bigger range of possibility. +const percentageMultiplier = float64(1000) + +// FlagData describe the fields of a flag. +type FlagData struct { + // Rule is the query use to select on which user the flag should apply. + // Rule format is based on the nikunjy/rules module. + // If no rule set, the flag apply to all users (percentage still apply). + Rule *string `json:"rule,omitempty" yaml:"rule,omitempty" toml:"rule,omitempty"` + + // Percentage of the users affect by the flag. + // Default value is 0 + Percentage *float64 `json:"percentage,omitempty" yaml:"percentage,omitempty" toml:"percentage,omitempty"` + + // True is the value return by the flag if apply to the user (rule is evaluated to true) + // and user is in the active percentage. + True *interface{} `json:"true,omitempty" yaml:"true,omitempty" toml:"true,omitempty"` + + // False is the value return by the flag if apply to the user (rule is evaluated to true) + // and user is not in the active percentage. + False *interface{} `json:"false,omitempty" yaml:"false,omitempty" toml:"false,omitempty"` + + // Default is the value return by the flag if not apply to the user (rule is evaluated to false). + Default *interface{} `json:"default,omitempty" yaml:"default,omitempty" toml:"default,omitempty"` + + // TrackEvents is false if you don't want to export the data in your data exporter. + // Default value is true + TrackEvents *bool `json:"trackEvents,omitempty" yaml:"trackEvents,omitempty" toml:"trackEvents,omitempty"` + + // Disable is true if the flag is disabled. + Disable *bool `json:"disable,omitempty" yaml:"disable,omitempty" toml:"disable,omitempty"` + + // Rollout is the object to configure how the flag is rollout. + // You have different rollout strategy available but only one is used at a time. + Rollout *Rollout `json:"rollout,omitempty" yaml:"rollout,omitempty" toml:"rollout,omitempty"` + + // Version (optional) This field contains the version of the flag. + // The version is manually managed when you configure your flags and it is used to display the information + // in the notifications and data collection. + Version *float64 `json:"version,omitempty" yaml:"version,omitempty" toml:"version,omitempty"` +} + +// Value is returning the Value associate to the flag (True / False / Default ) based +// if the toggle apply to the user or not. +func (f *FlagData) Value( + flagName string, + user ffuser.User, + evaluationCtx flag.EvaluationContext, +) (interface{}, flag.ResolutionDetails) { + f.updateFlagStage() + if f.isExperimentationOver() { + // if we have an experimentation that has not started or that is finished we use the default value. + return f.getDefault(), flag.ResolutionDetails{ + Variant: VariationDefault, + Reason: flag.ReasonDefault, + } + } + + // Flag disable we cannot apply it. + if f.GetDisable() { + return evaluationCtx.DefaultSdkValue, flag.ResolutionDetails{ + Variant: flag.VariationSDKDefault, + Reason: flag.ReasonDisabled, + } + } + + // we are targeting all users + if f.getRule() == "" && f.getPercentage() == 100 { + return f.getTrue(), flag.ResolutionDetails{ + Variant: VariationTrue, + Reason: flag.ReasonTargetingMatch, + } + } + + if f.evaluateRule(user, evaluationCtx.Environment) { + if f.isInPercentage(flagName, user) { + // Rule applied and user in the cohort. + return f.getTrue(), flag.ResolutionDetails{ + Variant: VariationTrue, + Reason: flag.ReasonSplit, + } + } + // Rule applied and user not in the cohort. + return f.getFalse(), flag.ResolutionDetails{ + Variant: VariationFalse, + Reason: flag.ReasonSplit, + } + } + + // Default value is used if the rule does not apply to the user. + return f.getDefault(), flag.ResolutionDetails{ + Variant: VariationDefault, + Reason: flag.ReasonDefault, + } +} + +func (f *FlagData) isExperimentationOver() bool { + now := time.Now() + return f.Rollout != nil && f.Rollout.Experimentation != nil && + ((f.Rollout.Experimentation.Start != nil && now.Before(*f.Rollout.Experimentation.Start)) || + (f.Rollout.Experimentation.End != nil && now.After(*f.Rollout.Experimentation.End))) +} + +// isInPercentage check if the user is in the cohort for the toggle. +func (f *FlagData) isInPercentage(flagName string, user ffuser.User) bool { + percentage := int32(f.getActualPercentage()) + maxPercentage := uint32(100 * percentageMultiplier) + + // <= 0% + if percentage <= 0 { + return false + } + // >= 100% + if uint32(percentage) >= maxPercentage { + return true + } + + hashID := utils.Hash(flagName+user.GetKey()) % maxPercentage + return hashID < uint32(percentage) +} + +// evaluateRule is checking if the rule can apply to a specific user. +func (f *FlagData) evaluateRule(user ffuser.User, environment string) bool { + // No rule means that all user can be impacted. + if f.getRule() == "" { + return true + } + + // Evaluate the rule on the user. + userMap := utils.UserToMap(user) + if environment != "" { + userMap["env"] = environment + } + return parser.Evaluate(f.getRule(), userMap) +} + +// string display correctly a flag +func (f FlagData) String() string { + toString := []string{} + toString = append(toString, fmt.Sprintf("percentage=%d%%", int64(math.Round(f.getPercentage())))) + if f.getRule() != "" { + toString = append(toString, fmt.Sprintf("rule=\"%s\"", f.getRule())) + } + toString = append(toString, fmt.Sprintf("true=\"%v\"", f.getTrue())) + toString = append(toString, fmt.Sprintf("false=\"%v\"", f.getFalse())) + toString = append(toString, fmt.Sprintf("default=\"%v\"", f.getDefault())) + toString = append(toString, fmt.Sprintf("disable=\"%v\"", f.GetDisable())) + + if f.TrackEvents != nil { + toString = append(toString, fmt.Sprintf("trackEvents=\"%v\"", f.GetTrackEvents())) + } + + if f.Version != nil { + toString = append(toString, fmt.Sprintf("version=%s", strconv.FormatFloat(f.GetVersion(), 'f', -1, 64))) + } + + return strings.Join(toString, ", ") +} + +// getActualPercentage return the the actual percentage of the flag. +// the result value is the version with the percentageMultiplier. +func (f *FlagData) getActualPercentage() float64 { + flagPercentage := f.getPercentage() * percentageMultiplier + if f.Rollout == nil || f.Rollout.Progressive == nil { + return flagPercentage + } + + // compute progressive rollout percentage + now := time.Now() + + // Missing date we ignore the progressive rollout + if f.Rollout.Progressive.ReleaseRamp.Start == nil || f.Rollout.Progressive.ReleaseRamp.End == nil { + return flagPercentage + } + // Expand percentage with the percentageMultiplier + initialPercentage := f.Rollout.Progressive.Percentage.Initial * percentageMultiplier + if f.Rollout.Progressive.Percentage.End == 0 { + f.Rollout.Progressive.Percentage.End = 100 + } + endPercentage := f.Rollout.Progressive.Percentage.End * percentageMultiplier + + if f.Rollout.Progressive.Percentage.Initial > f.Rollout.Progressive.Percentage.End { + return flagPercentage + } + + // Not in the range of the progressive rollout + if now.Before(*f.Rollout.Progressive.ReleaseRamp.Start) { + return initialPercentage + } + if now.After(*f.Rollout.Progressive.ReleaseRamp.End) { + return endPercentage + } + + // during the rollout ramp we compute the percentage + nbSec := f.Rollout.Progressive.ReleaseRamp.End.Unix() - f.Rollout.Progressive.ReleaseRamp.Start.Unix() + percentage := endPercentage - initialPercentage + percentPerSec := percentage / float64(nbSec) + + c := now.Unix() - f.Rollout.Progressive.ReleaseRamp.Start.Unix() + currentPercentage := float64(c)*percentPerSec + initialPercentage + return currentPercentage +} + +func (f *FlagData) updateFlagStage() { + if f.Rollout == nil || f.Rollout.Scheduled == nil || len(f.Rollout.Scheduled.Steps) == 0 { + // no update required because no scheduled rollout configuration + return + } + + now := time.Now() + for _, step := range f.Rollout.Scheduled.Steps { + // if the step has no date we ignore it + if step.Date == nil { + continue + } + + // as soon as we have a step in the future we stop the updates + if now.Before(*step.Date) { + break + } + + if step.Date != nil && now.After(*step.Date) { + f.mergeChanges(step) + } + } +} + +// mergeChanges will check every changes on the flag and apply them to the current configuration. +func (f *FlagData) mergeChanges(stepFlag ScheduledStep) { + if stepFlag.Disable != nil { + f.Disable = stepFlag.Disable + } + if stepFlag.False != nil { + f.False = stepFlag.False + } + if stepFlag.True != nil { + f.True = stepFlag.True + } + if stepFlag.Default != nil { + f.Default = stepFlag.Default + } + if stepFlag.TrackEvents != nil { + f.TrackEvents = stepFlag.TrackEvents + } + if stepFlag.Percentage != nil { + f.Percentage = stepFlag.Percentage + } + if stepFlag.Rule != nil { + f.Rule = stepFlag.Rule + } + if stepFlag.Rollout != nil { + f.Rollout = stepFlag.Rollout + } + if stepFlag.Version != nil { + f.Version = stepFlag.Version + } +} + +// GetRule is the getter of the field Rule +func (f *FlagData) getRule() string { + if f.Rule == nil { + return "" + } + return *f.Rule +} + +// GetPercentage is the getter of the field Percentage +func (f *FlagData) getPercentage() float64 { + if f.Percentage == nil { + return 0 + } + return *f.Percentage +} + +// GetTrue is the getter of the field True +func (f *FlagData) getTrue() interface{} { + if f.True == nil { + return nil + } + return *f.True +} + +// f.getFalse is the getter of the field False +func (f *FlagData) getFalse() interface{} { + if f.False == nil { + return nil + } + return *f.False +} + +// GetDefault is the getter of the field Default +func (f *FlagData) getDefault() interface{} { + if f.Default == nil { + return nil + } + return *f.Default +} + +// GetTrackEvents is the getter of the field TrackEvents +func (f *FlagData) GetTrackEvents() bool { + if f.TrackEvents == nil { + return true + } + return *f.TrackEvents +} + +// GetDisable is the getter for the field Disable +func (f *FlagData) GetDisable() bool { + if f.Disable == nil { + return false + } + return *f.Disable +} + +// GetRollout is the getter for the field Rollout +func (f *FlagData) getRollout() *Rollout { + return f.Rollout +} + +// GetVersion is the getter for the field Version +func (f *FlagData) GetVersion() float64 { + if f.Version == nil { + return 0 + } + return *f.Version +} + +// GetVariationValue return the value of variation from his name +func (f *FlagData) GetVariationValue(variationName string) interface{} { + switch variationName { + case VariationDefault: + return f.getDefault() + case VariationTrue: + return f.getTrue() + case VariationFalse: + return f.getFalse() + default: + return nil + } +} + +func (f *FlagData) GetDefaultVariation() string { + return VariationDefault +} + +func (f *FlagData) GetRawValues() map[string]string { + rawValues := make(map[string]string) + rawValues["Rule"] = f.getRule() + rawValues["Percentage"] = fmt.Sprintf("%.2f", f.getPercentage()) + + if f.getRollout() == nil { + rawValues["Rollout"] = "" + } else { + rawValues["Rollout"] = fmt.Sprintf("%v", f.getRollout()) + } + rawValues["True"] = convertNilEmpty(f.getTrue()) + rawValues["False"] = convertNilEmpty(f.getFalse()) + rawValues["Default"] = convertNilEmpty(f.getDefault()) + rawValues["TrackEvents"] = fmt.Sprintf("%t", f.GetTrackEvents()) + rawValues["Disable"] = fmt.Sprintf("%t", f.GetDisable()) + rawValues["Version"] = fmt.Sprintf("%v", f.GetVersion()) + return rawValues +} + +func convertNilEmpty(input interface{}) string { + if input == nil { + return "" + } + return fmt.Sprintf("%v", input) +} diff --git a/testutils/flagv1/rollout.go b/testutils/flagv1/rollout.go new file mode 100644 index 00000000000..13d14294818 --- /dev/null +++ b/testutils/flagv1/rollout.go @@ -0,0 +1,97 @@ +package flagv1 + +import ( + "fmt" + "strings" + "time" +) + +type Rollout struct { + // Experimentation is your struct to configure an experimentation, it will allow you to configure a start date and + // an end date for your flag. + // When the experimentation is not running, the flag will serve the default value. + Experimentation *Experimentation `json:"experimentation,omitempty" yaml:"experimentation,omitempty" toml:"experimentation,omitempty"` // nolint: lll + + // Progressive is your struct to configure a progressive rollout deployment of your flag. + // It will allow you to ramp up the percentage of your flag over time. + // You can decide at which percentage you starts and at what percentage you ends in your release ramp. + // Before the start date we will serve the initial percentage and after we will serve the end percentage. + Progressive *Progressive `json:"progressive,omitempty" yaml:"progressive,omitempty" toml:"progressive,omitempty"` // nolint: lll + + // Scheduled is your struct to configure an update on some fields of your flag over time. + // You can add several steps that updates the flag, this is typically used if you want to gradually add more user + // in your flag. + Scheduled *ScheduledRollout `json:"scheduled,omitempty" yaml:"scheduled,omitempty" toml:"scheduled,omitempty"` // nolint: lll +} + +func (e Rollout) String() string { + // TODO: other rollout + if e.Experimentation == nil { + return "" + } + return "experimentation: " + e.Experimentation.String() +} + +type Experimentation struct { + // Start is the starting time of the experimentation + Start *time.Time `json:"start,omitempty" yaml:"start,omitempty" toml:"start,omitempty"` + + // End is the ending time of the experimentation + End *time.Time `json:"end,omitempty" yaml:"end,omitempty" toml:"end,omitempty"` +} + +func (e Experimentation) String() string { + buf := make([]string, 0) + lo, _ := time.LoadLocation("UTC") + + if e.Start != nil { + buf = append(buf, fmt.Sprintf("start:[%v]", e.Start.In(lo).Format(time.RFC3339))) + } + if e.End != nil { + buf = append(buf, fmt.Sprintf("end:[%v]", e.End.In(lo).Format(time.RFC3339))) + } + return strings.Join(buf, " ") +} + +// Progressive is the configuration struct to define a progressive rollout. +type Progressive struct { + // Percentage is where you can configure at what percentage your progressive rollout start + // and at what percentage it ends. + // This field is optional + Percentage ProgressivePercentage `json:"percentage,omitempty" yaml:"percentage,omitempty" toml:"percentage,omitempty"` + + // ReleaseRamp is the defining when the progressive rollout starts and ends. + // This field is mandatory if you want to use a progressive rollout. + // If any field missing we ignore the progressive rollout. + ReleaseRamp ProgressiveReleaseRamp `json:"releaseRamp,omitempty" yaml:"releaseRamp,omitempty" toml:"releaseRamp,omitempty"` // nolint: lll +} + +type ProgressivePercentage struct { + // Initial is the initial percentage before the rollout start date. + // This field is optional + // Default: 0.0 + Initial float64 `json:"initial,omitempty" yaml:"initial,omitempty" toml:"initial,omitempty"` + + // End is the target percentage we want to reach at the end of the rollout phase. + // This field is optional + // Default: 100.0 + End float64 `json:"end,omitempty" yaml:"end,omitempty" toml:"end,omitempty"` +} + +type ProgressiveReleaseRamp struct { + // Start is the starting time of the ramp + Start *time.Time `json:"start,omitempty" yaml:"start,omitempty" toml:"start,omitempty"` + + // End is the ending time of the ramp + End *time.Time `json:"end,omitempty" yaml:"end,omitempty" toml:"end,omitempty"` +} + +type ScheduledRollout struct { + // Steps is the list of updates to do in a specific date. + Steps []ScheduledStep `json:"steps,omitempty" yaml:"steps,omitempty" toml:"steps,omitempty"` +} + +type ScheduledStep struct { + FlagData `yaml:",inline"` + Date *time.Time `json:"date,omitempty" yaml:"date,omitempty" toml:"date,omitempty"` +} diff --git a/testutils/flagv1/variation_type.go b/testutils/flagv1/variation_type.go new file mode 100644 index 00000000000..1b60bdcb7cc --- /dev/null +++ b/testutils/flagv1/variation_type.go @@ -0,0 +1,12 @@ +package flagv1 + +const ( + // VariationTrue is a constant to explain that we are using the "True" variation + VariationTrue string = "True" + + // VariationFalse is a constant to explain that we are using the "False" variation + VariationFalse string = "False" + + // VariationDefault is a constant to explain that we are using the "Default" variation + VariationDefault string = "Default" +) From db81cf23963cd8d5fb0ff134d85c3d0e63e10735 Mon Sep 17 00:00:00 2001 From: Thomas Poignant Date: Sun, 7 Aug 2022 21:20:37 +0200 Subject: [PATCH 20/50] WIP Signed-off-by: Thomas Poignant --- internal/dto/converter_v0.go | 6 +++--- internal/dto/converter_v0_test.go | 8 ++++---- internal/dto/toremove_test.go | 6 +++--- testutils/flagv1/convert.go | 1 - 4 files changed, 10 insertions(+), 11 deletions(-) diff --git a/internal/dto/converter_v0.go b/internal/dto/converter_v0.go index dd19b183c98..3b1029c7aa3 100644 --- a/internal/dto/converter_v0.go +++ b/internal/dto/converter_v0.go @@ -2,6 +2,7 @@ package dto import ( "fmt" + "github.com/thomaspoignant/go-feature-flag/internal/flag" "github.com/thomaspoignant/go-feature-flag/testutils/testconvert" ) @@ -179,7 +180,6 @@ func createScheduledStep(f flag.InternalFlag, dto ScheduledStepV0) flag.Schedule // rules management switch { - case hasRuleBefore && !updateRule: // deactivate rule + update the default rule // activate the target rule @@ -214,7 +214,7 @@ func createScheduledStep(f flag.InternalFlag, dto ScheduledStepV0) flag.Schedule break case !hasRuleBefore && !updateRule: - //update the defaultRule + if dto.Percentage != nil { step.DefaultRule = &flag.Rule{ VariationResult: &emptyVarRes, @@ -246,7 +246,7 @@ func createScheduledStep(f flag.InternalFlag, dto ScheduledStepV0) flag.Schedule } // we have only a default rule - //if dto.Rule == nil && ruleIndex == nil { + // if dto.Rule == nil && ruleIndex == nil { // if dto.Percentage != nil { // step.DefaultRule = &flag.Rule{ // Name: &defaultRuleName, diff --git a/internal/dto/converter_v0_test.go b/internal/dto/converter_v0_test.go index 9caf2fa4cb2..0e94a482184 100644 --- a/internal/dto/converter_v0_test.go +++ b/internal/dto/converter_v0_test.go @@ -3,11 +3,12 @@ package dto_test import ( "encoding/json" "fmt" - "github.com/thomaspoignant/go-feature-flag/ffuser" - "github.com/thomaspoignant/go-feature-flag/testutils/flagv1" "testing" "time" + "github.com/thomaspoignant/go-feature-flag/ffuser" + "github.com/thomaspoignant/go-feature-flag/testutils/flagv1" + "github.com/stretchr/testify/assert" "github.com/thomaspoignant/go-feature-flag/internal/dto" "github.com/thomaspoignant/go-feature-flag/internal/flag" @@ -326,7 +327,7 @@ func TestConvertV0DtoToInternalFlag(t *testing.T) { Default: testconvert.Interface("default"), Rollout: &dto.RolloutV0{ Scheduled: &dto.ScheduledRolloutV0{Steps: []dto.ScheduledStepV0{ - //{ScheduledStepV0 + // {ScheduledStepV0 // DTOv0: dto.DTOv0{ // Percentage: testconvert.Float64(20), // }, @@ -731,5 +732,4 @@ func TestConvertV0ScheduleStep(t *testing.T) { assert.Equal(t, gotFlagV1, gotInternalFlag) }) } - } diff --git a/internal/dto/toremove_test.go b/internal/dto/toremove_test.go index e7b47c8a659..0707e7fc669 100644 --- a/internal/dto/toremove_test.go +++ b/internal/dto/toremove_test.go @@ -2,14 +2,15 @@ package dto_test import ( "fmt" + "testing" + "time" + "github.com/stretchr/testify/assert" "github.com/thomaspoignant/go-feature-flag/ffuser" "github.com/thomaspoignant/go-feature-flag/internal/dto" "github.com/thomaspoignant/go-feature-flag/internal/flag" "github.com/thomaspoignant/go-feature-flag/testutils/flagv1" "github.com/thomaspoignant/go-feature-flag/testutils/testconvert" - "testing" - "time" ) func Test_toto(t *testing.T) { @@ -102,6 +103,5 @@ func Test_toto(t *testing.T) { fmt.Println(m) assert.Equal(t, m, n) - //assert.Equal(t, n1, m1) } diff --git a/testutils/flagv1/convert.go b/testutils/flagv1/convert.go index 1ef2991e527..ade6890230c 100644 --- a/testutils/flagv1/convert.go +++ b/testutils/flagv1/convert.go @@ -59,5 +59,4 @@ func ConvertDtoToV1(d dto.DTOv0) FlagData { Disable: d.Disable, Rollout: &r, } - } From f62e565e078e02021aba09514f54b72fe88187af Mon Sep 17 00:00:00 2001 From: Thomas Poignant Date: Mon, 8 Aug 2022 00:34:28 +0200 Subject: [PATCH 21/50] Rework the convert layer Signed-off-by: Thomas Poignant --- .golangci.yml | 2 + internal/dto/converter_v0.go | 213 ++++++-------- internal/dto/converter_v0_test.go | 430 +++++++++++++++++++++------- internal/dto/toremove_test.go | 107 ------- internal/flag/internal_flag_test.go | 35 +++ internal/flag/rule.go | 4 - testutils/flagv1/convert.go | 36 ++- testutils/flagv1/flag_data.go | 3 - 8 files changed, 481 insertions(+), 349 deletions(-) delete mode 100644 internal/dto/toremove_test.go diff --git a/.golangci.yml b/.golangci.yml index 7b4e90583d9..f00b5009a49 100644 --- a/.golangci.yml +++ b/.golangci.yml @@ -37,6 +37,8 @@ linters-settings: - singleCaseSwitch golint: min-confidence: 0.6 + gosimple: + checks: ["all","-S1023"] issues: exclude-rules: - path: _test.go diff --git a/internal/dto/converter_v0.go b/internal/dto/converter_v0.go index 3b1029c7aa3..cfa7e396524 100644 --- a/internal/dto/converter_v0.go +++ b/internal/dto/converter_v0.go @@ -1,10 +1,7 @@ package dto import ( - "fmt" - "github.com/thomaspoignant/go-feature-flag/internal/flag" - "github.com/thomaspoignant/go-feature-flag/testutils/testconvert" ) var ( @@ -29,7 +26,7 @@ func ConvertV0DtoToInternalFlag(d DTOv0, isScheduledStep bool) flag.InternalFlag var variations *map[string]*interface{} newVariations := createVariationsV0(d, isScheduledStep) if newVariations != nil { - variations = &newVariations + variations = newVariations } var rules *[]flag.Rule @@ -148,7 +145,7 @@ func createLegacyRuleV0(d DTOv0) flag.Rule { } // createVariationsV0 will create a set of variations based on the previous format -func createVariationsV0(d DTOv0, isScheduleStep bool) map[string]*interface{} { +func createVariationsV0(d DTOv0, isScheduleStep bool) *map[string]*interface{} { variations := make(map[string]*interface{}, 3) if d.True != nil { variations[trueVariation] = d.True @@ -161,160 +158,105 @@ func createVariationsV0(d DTOv0, isScheduleStep bool) map[string]*interface{} { } if isScheduleStep && len(variations) == 0 { - variations = nil + return nil } - return variations + return &variations } +// createScheduledStep is converting the old format of scheduled step to the new one. +// since the format has changed a lot the logic in this function is a bit complex to follow. +// In the tests we are testing that we have the same results as the one returns by the old +// flag logic. func createScheduledStep(f flag.InternalFlag, dto ScheduledStepV0) flag.ScheduledStep { step := flag.ScheduledStep{ Date: dto.Date, + InternalFlag: flag.InternalFlag{ + Variations: createVariationsV0(dto.DTOv0, true), + }, } - variations := createVariationsV0(dto.DTOv0, true) - step.Variations = &variations - - ruleIndex := f.GetRuleIndexByName(LegacyRuleName) - hasRuleBefore := ruleIndex != nil && !f.GetRules()[*ruleIndex].IsDisable() + legacyRuleIndex := f.GetRuleIndexByName(LegacyRuleName) + hasRuleBefore := legacyRuleIndex != nil && !f.GetRules()[*legacyRuleIndex].IsDisable() updateRule := dto.Rule != nil + progressive := convertScheduledStepProgressiveRollout(dto) - // rules management switch { case hasRuleBefore && !updateRule: - // deactivate rule + update the default rule - // activate the target rule - if dto.Percentage != nil { - step.Rules = &[]flag.Rule{{ - Name: testconvert.String(LegacyRuleName), - Percentages: computePercentages(*dto.Percentage), - }} + if progressive != nil { + step.Rules = &[]flag.Rule{{Name: &LegacyRuleName, ProgressiveRollout: progressive}} + } else if dto.Percentage != nil { + step.Rules = &[]flag.Rule{{Name: &LegacyRuleName, Percentages: computePercentages(*dto.Percentage)}} } - fmt.Println("1") break case !hasRuleBefore && updateRule: if *dto.Rule == "" { - // disable target + update default - step.Rules = &[]flag.Rule{{ - Name: testconvert.String(LegacyRuleName), - Disable: &disableRuleValue, - }} - - step.DefaultRule = &flag.Rule{ - Name: testconvert.String(defaultRuleName), - } + step.Rules = &[]flag.Rule{{Name: &LegacyRuleName, Disable: &disableRuleValue}} + step.DefaultRule = &flag.Rule{Name: &defaultRuleName} - if dto.Percentage != nil { + if progressive != nil { + step.DefaultRule.ProgressiveRollout = progressive + } else if dto.Percentage != nil { step.DefaultRule.Percentages = computePercentages(*dto.Percentage) } } else { - // TODO: Update target + r := flag.Rule{Name: &LegacyRuleName, Disable: &enableRuleValue, Query: dto.Rule} + + switch { + case progressive != nil: + r.ProgressiveRollout = progressive + break + case dto.Percentage != nil: + r.Percentages = computePercentages(*dto.Percentage) + break + case f.DefaultRule != nil && f.DefaultRule.Percentages != nil && len(f.GetDefaultRule().GetPercentages()) > 0: + r.Percentages = deepCopyPercentages(f.GetDefaultRule().GetPercentages()) + break + default: + // no explicit percentage, default value is 0 + r.Percentages = computePercentages(0) + break + } + step.Rules = &[]flag.Rule{r} + + // clean up the default value + step.DefaultRule = &flag.Rule{ + Name: &defaultRuleName, + Percentages: &map[string]float64{trueVariation: -1, falseVariation: -1}, + VariationResult: &defaultVariation, + } } - fmt.Println("2") break case !hasRuleBefore && !updateRule: - - if dto.Percentage != nil { + if progressive != nil { + step.DefaultRule = &flag.Rule{VariationResult: &emptyVarRes, Name: &defaultRuleName, ProgressiveRollout: progressive} + } else if dto.Percentage != nil { step.DefaultRule = &flag.Rule{ VariationResult: &emptyVarRes, - Name: testconvert.String(defaultRuleName), + Name: &defaultRuleName, Percentages: computePercentages(*dto.Percentage), } } - fmt.Println("3") break case hasRuleBefore && updateRule: - // update targeting - if dto.Rule != nil { - r := flag.Rule{ - Name: testconvert.String(LegacyRuleName), - Query: dto.Rule, - Disable: &enableRuleValue, - } - if dto.Percentage != nil { - r.VariationResult = &emptyVarRes - r.Percentages = computePercentages(*dto.Percentage) - } - step.Rules = &[]flag.Rule{r} - } else { - // TODO: disable targeting and update default + r := flag.Rule{Name: &LegacyRuleName, Query: dto.Rule, Disable: &enableRuleValue} + + if progressive != nil { + r.VariationResult = &emptyVarRes + r.ProgressiveRollout = progressive + } else if dto.Percentage != nil { + r.VariationResult = &emptyVarRes + r.Percentages = computePercentages(*dto.Percentage) } - fmt.Println("4") + step.Rules = &[]flag.Rule{r} break } - // we have only a default rule - // if dto.Rule == nil && ruleIndex == nil { - // if dto.Percentage != nil { - // step.DefaultRule = &flag.Rule{ - // Name: &defaultRuleName, - // Percentages: computePercentages(*dto.Percentage), - // } - // } - //} - // - //if dto.Rule != nil && *dto.Rule == "" && ruleIndex != nil { - // disable := true - // r := flag.Rule{ - // Name: testconvert.String(LegacyRuleName), - // Disable: &disable, - // } - // step.Rules = &[]flag.Rule{r} - //} - // - //// We add a rule before or we update the query - //if dto.Rule != nil || (ruleIndex != nil && !f.GetRules()[*ruleIndex].IsDisable()) { - // r := flag.Rule{ - // Name: testconvert.String(LegacyRuleName), - // Query: dto.Rule, - // } - // - // if dto.Percentage != nil { - // if ruleIndex != nil && f.GetRules()[*ruleIndex].VariationResult != nil { - // r.VariationResult = testconvert.String("") - // } - // r.Percentages = computePercentages(*dto.Percentage) - // } else if ruleIndex != nil && f.GetRules()[*ruleIndex].Percentages != nil { - // r.Percentages = deepCopyPercentages(f.GetRules()[*ruleIndex].GetPercentages()) - // } else if ruleIndex == nil && f.GetDefaultRule() != nil { - // r.Percentages = deepCopyPercentages(f.GetDefaultRule().GetPercentages()) - // } - // - // // if we did not have rules before we migrate the percentage into the rule - // if ruleIndex == nil && dto.Percentage == nil { - // r.Percentages = deepCopyPercentages(f.GetDefaultRule().GetPercentages()) - // } - // - // // remove all percentages from default rule - // if f.GetDefaultRule().Percentages != nil { - // removedPercentages := map[string]float64{} - // for k, _ := range f.GetDefaultRule().GetPercentages() { - // removedPercentages[k] = -1 - // } - // step.DefaultRule = &flag.Rule{ - // Percentages: &removedPercentages, - // Name: &defaultRuleName, - // VariationResult: &defaultVariation, - // } - // } - // - // step.Rules = &[]flag.Rule{r} - //} - - if dto.Disable != nil { - step.Disable = dto.Disable - } - - if dto.TrackEvents != nil { - step.TrackEvents = dto.TrackEvents - } - - if dto.Version != nil { - step.Version = dto.Version - } - + step.Disable = dto.Disable + step.TrackEvents = dto.TrackEvents + step.Version = dto.Version return step } @@ -349,6 +291,7 @@ func computePercentages(percentage float64) *map[string]float64 { } } +// deepCopyPercentages is creating a new map with the same values func deepCopyPercentages(in map[string]float64) *map[string]float64 { p := make(map[string]float64, len(in)) // deep copy of the percentages to avoid being override @@ -357,3 +300,29 @@ func deepCopyPercentages(in map[string]float64) *map[string]float64 { } return &p } + +// convertProgressiveRollout convert the legacy format to the new format. +// If we can't convert we return a nil value. +func convertScheduledStepProgressiveRollout(dto ScheduledStepV0) *flag.ProgressiveRollout { + hasProgressiveRollout := dto.Rollout != nil && + dto.Rollout.Progressive != nil && + dto.Rollout.Progressive.ReleaseRamp.End != nil && + dto.Rollout.Progressive.ReleaseRamp.Start != nil + + var progressive *flag.ProgressiveRollout + if hasProgressiveRollout { + progressive = &flag.ProgressiveRollout{ + Initial: &flag.ProgressiveRolloutStep{ + Variation: &falseVariation, + Percentage: &dto.Rollout.Progressive.Percentage.Initial, + Date: dto.Rollout.Progressive.ReleaseRamp.Start, + }, + End: &flag.ProgressiveRolloutStep{ + Variation: &trueVariation, + Percentage: &dto.Rollout.Progressive.Percentage.End, + Date: dto.Rollout.Progressive.ReleaseRamp.End, + }, + } + } + return progressive +} diff --git a/internal/dto/converter_v0_test.go b/internal/dto/converter_v0_test.go index 0e94a482184..e1efabc3ec9 100644 --- a/internal/dto/converter_v0_test.go +++ b/internal/dto/converter_v0_test.go @@ -318,104 +318,6 @@ func TestConvertV0DtoToInternalFlag(t *testing.T) { }, }, }, - { - name: "Flag with percentage + scheduled step", - d: dto.DTOv0{ - Percentage: testconvert.Float64(10), - True: testconvert.Interface("true"), - False: testconvert.Interface("false"), - Default: testconvert.Interface("default"), - Rollout: &dto.RolloutV0{ - Scheduled: &dto.ScheduledRolloutV0{Steps: []dto.ScheduledStepV0{ - // {ScheduledStepV0 - // DTOv0: dto.DTOv0{ - // Percentage: testconvert.Float64(20), - // }, - // Date: testconvert.Time(time.Date(2021, time.February, 2, 10, 10, 10, 10, time.UTC)), - // }, - //{ - // DTOv0: dto.DTOv0{ - // True: testconvert.Interface("true2"), - // }, - // Date: testconvert.Time(time.Date(2021, time.February, 3, 10, 10, 10, 10, time.UTC)), - // }, - { - DTOv0: dto.DTOv0{ - Rule: testconvert.String("key eq \"test-user\""), - }, - Date: testconvert.Time(time.Date(2021, time.February, 4, 10, 10, 10, 10, time.UTC)), - }, - }}, - }, - }, - want: flag.InternalFlag{ - Variations: &map[string]*interface{}{ - "Default": testconvert.Interface("default"), - "False": testconvert.Interface("false"), - "True": testconvert.Interface("true"), - }, - DefaultRule: &flag.Rule{ - Name: testconvert.String("legacyDefaultRule"), - Percentages: &map[string]float64{ - "True": 10, - "False": 90, - }, - }, - Rollout: &flag.Rollout{ - Scheduled: &[]flag.ScheduledStep{ - { - InternalFlag: flag.InternalFlag{ - DefaultRule: &flag.Rule{ - Name: testconvert.String("legacyDefaultRule"), - Percentages: &map[string]float64{ - "False": 80, - "True": 20, - }, - }, - }, - Date: testconvert.Time(time.Date(2021, time.February, 2, 10, 10, 10, 10, time.UTC)), - }, - { - InternalFlag: flag.InternalFlag{ - Variations: &map[string]*interface{}{ - "Default": testconvert.Interface("default"), - "False": testconvert.Interface("false"), - "True": testconvert.Interface("true2"), - }, - DefaultRule: &flag.Rule{ - Name: testconvert.String("legacyDefaultRule"), - Percentages: &map[string]float64{ - "False": 80, - "True": 20, - }, - }, - }, - Date: testconvert.Time(time.Date(2021, time.February, 3, 10, 10, 10, 10, time.UTC)), - }, - { - InternalFlag: flag.InternalFlag{ - Variations: &map[string]*interface{}{ - "Default": testconvert.Interface("default"), - "False": testconvert.Interface("false"), - "True": testconvert.Interface("true2"), - }, - Rules: &[]flag.Rule{ - { - Name: testconvert.String("legacyRuleV0"), - Query: testconvert.String("key eq \"test-user\""), - }, - }, - DefaultRule: &flag.Rule{ - Name: testconvert.String("legacyDefaultRule"), - VariationResult: testconvert.String("Default"), - }, - }, - Date: testconvert.Time(time.Date(2021, time.February, 4, 10, 10, 10, 10, time.UTC)), - }, - }, - }, - }, - }, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { @@ -683,7 +585,123 @@ func TestConvertV0ScheduleStep(t *testing.T) { }, }, { - name: "XXX", + name: "Rule with percentages, remove rule", + dto: dto.DTO{ + DTOv0: dto.DTOv0{ + True: testconvert.Interface("true"), + False: testconvert.Interface("false"), + Default: testconvert.Interface("default"), + Rule: testconvert.String("key eq \"yo\""), + Percentage: testconvert.Float64(95), + Rollout: &dto.RolloutV0{ + Scheduled: &dto.ScheduledRolloutV0{Steps: []dto.ScheduledStepV0{ + { + DTOv0: dto.DTOv0{ + Rule: testconvert.String(""), + }, + Date: testconvert.Time(time.Now().Add(-2 * time.Second)), + }, + }}, + }, + }, + }, + }, + { + name: "Rule with percentages, update progressive rollout in the past", + dto: dto.DTO{ + DTOv0: dto.DTOv0{ + True: testconvert.Interface("true"), + False: testconvert.Interface("false"), + Default: testconvert.Interface("default"), + Rule: testconvert.String("key eq \"yo\""), + Percentage: testconvert.Float64(0), + Rollout: &dto.RolloutV0{ + Scheduled: &dto.ScheduledRolloutV0{Steps: []dto.ScheduledStepV0{ + { + DTOv0: dto.DTOv0{ + Rollout: &dto.RolloutV0{ + Progressive: &dto.ProgressiveV0{ + Percentage: dto.ProgressivePercentageV0{ + Initial: 0, + End: 100, + }, + ReleaseRamp: dto.ProgressiveReleaseRampV0{ + Start: testconvert.Time(time.Now().Add(-300 * time.Second)), + End: testconvert.Time(time.Now().Add(-1 * time.Second)), + }, + }, + }, + }, + Date: testconvert.Time(time.Now().Add(-2 * time.Second)), + }, + }}, + }, + }, + }, + }, + { + name: "Rule with percentages, update progressive rollout pending", + dto: dto.DTO{ + DTOv0: dto.DTOv0{ + True: testconvert.Interface("true"), + False: testconvert.Interface("false"), + Default: testconvert.Interface("default"), + Rule: testconvert.String("key eq \"yo\""), + Percentage: testconvert.Float64(0), + Rollout: &dto.RolloutV0{ + Scheduled: &dto.ScheduledRolloutV0{Steps: []dto.ScheduledStepV0{ + { + DTOv0: dto.DTOv0{ + Rollout: &dto.RolloutV0{ + Progressive: &dto.ProgressiveV0{ + Percentage: dto.ProgressivePercentageV0{ + Initial: 0, + End: 100, + }, + ReleaseRamp: dto.ProgressiveReleaseRampV0{ + Start: testconvert.Time(time.Now().Add(-1 * time.Second)), + End: testconvert.Time(time.Now().Add(600 * time.Second)), + }, + }, + }, + }, + Date: testconvert.Time(time.Now().Add(-2 * time.Second)), + }, + }}, + }, + }, + }, + }, + { + name: "Schedule an experimentation", + dto: dto.DTO{ + DTOv0: dto.DTOv0{ + True: testconvert.Interface("true"), + False: testconvert.Interface("false"), + Default: testconvert.Interface("default"), + Rule: testconvert.String("key eq \"yo\""), + Percentage: testconvert.Float64(0), + Rollout: &dto.RolloutV0{ + Scheduled: &dto.ScheduledRolloutV0{Steps: []dto.ScheduledStepV0{ + { + DTOv0: dto.DTOv0{ + Percentage: testconvert.Float64(100), + Rollout: &dto.RolloutV0{ + Experimentation: &dto.ExperimentationV0{ + Start: testconvert.Time(time.Now().Add(-1 * time.Second)), + End: testconvert.Time(time.Now().Add(600 * time.Second)), + }, + }, + }, + Date: testconvert.Time(time.Now().Add(-2 * time.Second)), + }, + }}, + }, + }, + }, + }, + { + name: "Multiple changes at the same time", dto: dto.DTO{ DTOv0: dto.DTOv0{ True: testconvert.Interface("true"), @@ -695,19 +713,223 @@ func TestConvertV0ScheduleStep(t *testing.T) { Scheduled: &dto.ScheduledRolloutV0{Steps: []dto.ScheduledStepV0{ { DTOv0: dto.DTOv0{ - Rule: testconvert.String("key eq \"oy\""), + Percentage: testconvert.Float64(10), + }, + Date: testconvert.Time(time.Now().Add(-2 * time.Second)), + }, + { + DTOv0: dto.DTOv0{ + Rule: testconvert.String("key eq \"yo\""), + }, + Date: testconvert.Time(time.Now().Add(-2 * time.Second)), + }, + { + DTOv0: dto.DTOv0{ + True: testconvert.Interface("newValue"), + }, + Date: testconvert.Time(time.Now().Add(-2 * time.Second)), + }, + { + DTOv0: dto.DTOv0{ + Percentage: testconvert.Float64(10), + }, + Date: testconvert.Time(time.Now().Add(-2 * time.Second)), + }, + { + DTOv0: dto.DTOv0{ + Rule: testconvert.String(""), + Percentage: testconvert.Float64(100), + }, + Date: testconvert.Time(time.Now().Add(-2 * time.Second)), + }, + { + DTOv0: dto.DTOv0{ + Disable: testconvert.Bool(true), }, Date: testconvert.Time(time.Now().Add(-2 * time.Second)), }, { DTOv0: dto.DTOv0{ + Disable: testconvert.Bool(false), + Rule: testconvert.String("anonymous eq false"), + Percentage: testconvert.Float64(100), + }, + Date: testconvert.Time(time.Now().Add(-2 * time.Second)), + }, + { + DTOv0: dto.DTOv0{ + Rollout: &dto.RolloutV0{ + Experimentation: &dto.ExperimentationV0{ + Start: testconvert.Time(time.Now().Add(-2 * time.Second)), + End: testconvert.Time(time.Now().Add(2 * time.Second)), + }, + }, + }, + Date: testconvert.Time(time.Now().Add(-2 * time.Second)), + }, + { + DTOv0: dto.DTOv0{ + Rollout: &dto.RolloutV0{ + Experimentation: &dto.ExperimentationV0{ + End: testconvert.Time(time.Now().Add(-2 * time.Second)), + }, + }, + }, + Date: testconvert.Time(time.Now().Add(-2 * time.Second)), + }, + }}, + }, + }, + }, + }, + { + name: "No rule before, and update rule empty string", + dto: dto.DTO{ + DTOv0: dto.DTOv0{ + True: testconvert.Interface("true"), + False: testconvert.Interface("false"), + Default: testconvert.Interface("default"), + Percentage: testconvert.Float64(100), + Rollout: &dto.RolloutV0{ + Scheduled: &dto.ScheduledRolloutV0{Steps: []dto.ScheduledStepV0{ + { + DTOv0: dto.DTOv0{ + Rule: testconvert.String(""), Percentage: testconvert.Float64(95), }, Date: testconvert.Time(time.Now().Add(-2 * time.Second)), }, + }}, + }, + }, + }, + }, + { + name: "No rule before, and no rule after just adding progressive rollout", + dto: dto.DTO{ + DTOv0: dto.DTOv0{ + True: testconvert.Interface("true"), + False: testconvert.Interface("false"), + Default: testconvert.Interface("default"), + Rollout: &dto.RolloutV0{ + Scheduled: &dto.ScheduledRolloutV0{Steps: []dto.ScheduledStepV0{ { DTOv0: dto.DTOv0{ - Rule: testconvert.String("key eq \"yo\""), + Rollout: &dto.RolloutV0{ + Progressive: &dto.ProgressiveV0{ + Percentage: dto.ProgressivePercentageV0{ + Initial: 0, + End: 100, + }, + ReleaseRamp: dto.ProgressiveReleaseRampV0{ + Start: testconvert.Time(time.Now().Add(10 * time.Minute)), + End: testconvert.Time(time.Now().Add(20 * time.Minute)), + }, + }, + }, + }, + Date: testconvert.Time(time.Now().Add(-2 * time.Second)), + }, + }}, + }, + }, + }, + }, + { + name: "Update rule + add progressive", + dto: dto.DTO{ + DTOv0: dto.DTOv0{ + True: testconvert.Interface("true"), + False: testconvert.Interface("false"), + Default: testconvert.Interface("default"), + Rule: testconvert.String("key eq \"yo\""), + Rollout: &dto.RolloutV0{ + Scheduled: &dto.ScheduledRolloutV0{Steps: []dto.ScheduledStepV0{ + { + DTOv0: dto.DTOv0{ + Rule: testconvert.String("anonymous eq false"), + TrackEvents: testconvert.Bool(true), + Version: testconvert.String("1.0.1"), + Rollout: &dto.RolloutV0{ + Progressive: &dto.ProgressiveV0{ + Percentage: dto.ProgressivePercentageV0{ + Initial: 0, + End: 100, + }, + ReleaseRamp: dto.ProgressiveReleaseRampV0{ + Start: testconvert.Time(time.Now().Add(-10 * time.Minute)), + End: testconvert.Time(time.Now().Add(0 * time.Minute)), + }, + }, + }, + }, + Date: testconvert.Time(time.Now().Add(-2 * time.Second)), + }, + }}, + }, + }, + }, + }, + { + name: "No rule + add rule and progressive", + dto: dto.DTO{ + DTOv0: dto.DTOv0{ + True: testconvert.Interface("true"), + False: testconvert.Interface("false"), + Default: testconvert.Interface("default"), + Rollout: &dto.RolloutV0{ + Scheduled: &dto.ScheduledRolloutV0{Steps: []dto.ScheduledStepV0{ + { + DTOv0: dto.DTOv0{ + Rule: testconvert.String("anonymous eq false"), + TrackEvents: testconvert.Bool(true), + Version: testconvert.String("1.0.1"), + Rollout: &dto.RolloutV0{ + Progressive: &dto.ProgressiveV0{ + Percentage: dto.ProgressivePercentageV0{ + Initial: 0, + End: 100, + }, + ReleaseRamp: dto.ProgressiveReleaseRampV0{ + Start: testconvert.Time(time.Now().Add(-10 * time.Minute)), + End: testconvert.Time(time.Now().Add(0 * time.Minute)), + }, + }, + }, + }, + Date: testconvert.Time(time.Now().Add(-2 * time.Second)), + }, + }}, + }, + }, + }, + }, + { + name: "No rule + add empty rule and progressive", + dto: dto.DTO{ + DTOv0: dto.DTOv0{ + True: testconvert.Interface("true"), + False: testconvert.Interface("false"), + Default: testconvert.Interface("default"), + Rollout: &dto.RolloutV0{ + Scheduled: &dto.ScheduledRolloutV0{Steps: []dto.ScheduledStepV0{ + { + DTOv0: dto.DTOv0{ + Rule: testconvert.String(""), + TrackEvents: testconvert.Bool(true), + Version: testconvert.String("1.0.1"), + Rollout: &dto.RolloutV0{ + Progressive: &dto.ProgressiveV0{ + Percentage: dto.ProgressivePercentageV0{ + Initial: 0, + End: 100, + }, + ReleaseRamp: dto.ProgressiveReleaseRampV0{ + Start: testconvert.Time(time.Now().Add(-10 * time.Minute)), + End: testconvert.Time(time.Now().Add(0 * time.Minute)), + }, + }, + }, }, Date: testconvert.Time(time.Now().Add(-2 * time.Second)), }, @@ -723,13 +945,15 @@ func TestConvertV0ScheduleStep(t *testing.T) { flagName := "yo" convertInternalFlag := tt.dto.Convert() - gotInternalFlag, _ := convertInternalFlag.Value(flagName, u, flag.EvaluationContext{}) + gotInternalFlag, resolutionDetails := convertInternalFlag.Value(flagName, u, flag.EvaluationContext{}) convertFlagv1 := flagv1.ConvertDtoToV1(tt.dto.DTOv0) - gotFlagV1, _ := convertFlagv1.Value(flagName, u, flag.EvaluationContext{}) + gotFlagV1, resolutionDetails1 := convertFlagv1.Value(flagName, u, flag.EvaluationContext{}) fmt.Println(gotFlagV1, gotInternalFlag) assert.Equal(t, gotFlagV1, gotInternalFlag) + assert.Equal(t, resolutionDetails.Variant, resolutionDetails1.Variant) + assert.Equal(t, resolutionDetails.ErrorCode, resolutionDetails1.ErrorCode) }) } } diff --git a/internal/dto/toremove_test.go b/internal/dto/toremove_test.go deleted file mode 100644 index 0707e7fc669..00000000000 --- a/internal/dto/toremove_test.go +++ /dev/null @@ -1,107 +0,0 @@ -package dto_test - -import ( - "fmt" - "testing" - "time" - - "github.com/stretchr/testify/assert" - "github.com/thomaspoignant/go-feature-flag/ffuser" - "github.com/thomaspoignant/go-feature-flag/internal/dto" - "github.com/thomaspoignant/go-feature-flag/internal/flag" - "github.com/thomaspoignant/go-feature-flag/testutils/flagv1" - "github.com/thomaspoignant/go-feature-flag/testutils/testconvert" -) - -func Test_toto(t *testing.T) { - u := ffuser.NewUser("yo") - flagName := "yo" - d := dto.DTO{ - DTOv0: dto.DTOv0{ - True: testconvert.Interface("true"), - False: testconvert.Interface("false"), - Default: testconvert.Interface("default"), - Percentage: testconvert.Float64(100), - Rollout: &dto.RolloutV0{ - Scheduled: &dto.ScheduledRolloutV0{Steps: []dto.ScheduledStepV0{ - { - DTOv0: dto.DTOv0{ - Percentage: testconvert.Float64(10), - }, - Date: testconvert.Time(time.Now().Add(-2 * time.Second)), - }, - { - DTOv0: dto.DTOv0{ - Rule: testconvert.String("key eq \"yo\""), - }, - Date: testconvert.Time(time.Now().Add(-2 * time.Second)), - }, - { - DTOv0: dto.DTOv0{ - True: testconvert.Interface("newValue"), - }, - Date: testconvert.Time(time.Now().Add(-2 * time.Second)), - }, - { - DTOv0: dto.DTOv0{ - Percentage: testconvert.Float64(10), - }, - Date: testconvert.Time(time.Now().Add(-2 * time.Second)), - }, - { - DTOv0: dto.DTOv0{ - Rule: testconvert.String(""), - Percentage: testconvert.Float64(100), - }, - Date: testconvert.Time(time.Now().Add(-2 * time.Second)), - }, - { - DTOv0: dto.DTOv0{ - Disable: testconvert.Bool(true), - }, - Date: testconvert.Time(time.Now().Add(-2 * time.Second)), - }, - { - DTOv0: dto.DTOv0{ - Disable: testconvert.Bool(false), - Rule: testconvert.String("anonymous eq false"), - Percentage: testconvert.Float64(100), - }, - Date: testconvert.Time(time.Now().Add(-2 * time.Second)), - }, - { - DTOv0: dto.DTOv0{ - Rollout: &dto.RolloutV0{ - Experimentation: &dto.ExperimentationV0{ - Start: testconvert.Time(time.Now().Add(-2 * time.Second)), - End: testconvert.Time(time.Now().Add(2 * time.Second)), - }, - }, - }, - Date: testconvert.Time(time.Now().Add(-2 * time.Second)), - }, - { - DTOv0: dto.DTOv0{ - Rollout: &dto.RolloutV0{ - Experimentation: &dto.ExperimentationV0{ - End: testconvert.Time(time.Now().Add(-2 * time.Second)), - }, - }, - }, - Date: testconvert.Time(time.Now().Add(-2 * time.Second)), - }, - }}, - }, - }, - } - - c := d.Convert() - n, _ := c.Value(flagName, u, flag.EvaluationContext{}) - - e := flagv1.ConvertDtoToV1(d.DTOv0) - m, _ := e.Value(flagName, u, flag.EvaluationContext{}) - - fmt.Println(m) - assert.Equal(t, m, n) - -} diff --git a/internal/flag/internal_flag_test.go b/internal/flag/internal_flag_test.go index 4bc84051ef8..19bd7e74bb3 100644 --- a/internal/flag/internal_flag_test.go +++ b/internal/flag/internal_flag_test.go @@ -908,6 +908,41 @@ func TestInternalFlag_Value(t *testing.T) { Reason: flag.ReasonDefault, }, }, + { + name: "Should return the false value if not in between initial and end percentage", + flag: flag.InternalFlag{ + Variations: &map[string]*interface{}{ + "variation_A": testconvert.Interface("value_A"), + "variation_B": testconvert.Interface("value_B"), + }, + DefaultRule: &flag.Rule{ + ProgressiveRollout: &flag.ProgressiveRollout{ + Initial: &flag.ProgressiveRolloutStep{ + Variation: testconvert.String("variation_A"), + Percentage: testconvert.Float64(0), + Date: testconvert.Time(time.Now().Add(-10 * time.Second)), + }, + End: &flag.ProgressiveRolloutStep{ + Variation: testconvert.String("variation_B"), + Percentage: testconvert.Float64(5), + Date: testconvert.Time(time.Now().Add(-1 * time.Second)), + }, + }, + }, + }, + args: args{ + flagName: "my-flag", + user: ffuser.NewUserBuilder("user-key").Build(), + evaluationCtx: flag.EvaluationContext{ + DefaultSdkValue: "value_default", + }, + }, + want: "value_A", + want1: flag.ResolutionDetails{ + Variant: "variation_A", + Reason: flag.ReasonDefault, + }, + }, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { diff --git a/internal/flag/rule.go b/internal/flag/rule.go index 4a73e3ba842..f549b330b21 100644 --- a/internal/flag/rule.go +++ b/internal/flag/rule.go @@ -87,10 +87,6 @@ func (r *Rule) getVariationFromProgressiveRollout(hash uint32) (string, error) { return *r.ProgressiveRollout.Initial.Variation, nil } - if now.After(*r.ProgressiveRollout.End.Date) { - return *r.ProgressiveRollout.End.Variation, nil - } - // We are between initial and end initialPercentage := r.ProgressiveRollout.Initial.getPercentage() * PercentageMultiplier if r.ProgressiveRollout.End.getPercentage() == 0 || r.ProgressiveRollout.End.getPercentage() > 100 { diff --git a/testutils/flagv1/convert.go b/testutils/flagv1/convert.go index ade6890230c..c89f5fa57a1 100644 --- a/testutils/flagv1/convert.go +++ b/testutils/flagv1/convert.go @@ -21,17 +21,33 @@ func ConvertDtoToV1(d dto.DTOv0) FlagData { if d.Rollout.Scheduled.Steps != nil { r.Scheduled.Steps = []ScheduledStep{} for _, step := range d.Rollout.Scheduled.Steps { + f := FlagData{ + Rule: step.Rule, + Percentage: step.Percentage, + True: step.True, + False: step.False, + Default: step.Default, + TrackEvents: step.TrackEvents, + Disable: step.Disable, + } + if step.Rollout != nil && step.Rollout.Progressive != nil { + f.Rollout = &Rollout{ + Progressive: &Progressive{ + ReleaseRamp: ProgressiveReleaseRamp{ + Start: step.Rollout.Progressive.ReleaseRamp.Start, + End: step.Rollout.Progressive.ReleaseRamp.End, + }, + Percentage: ProgressivePercentage{ + Initial: step.Rollout.Progressive.Percentage.Initial, + End: step.Rollout.Progressive.Percentage.End, + }, + }, + } + } + s := ScheduledStep{ - FlagData: FlagData{ - Rule: step.Rule, - Percentage: step.Percentage, - True: step.True, - False: step.False, - Default: step.Default, - TrackEvents: step.TrackEvents, - Disable: step.Disable, - }, - Date: step.Date, + FlagData: f, + Date: step.Date, } r.Scheduled.Steps = append(r.Scheduled.Steps, s) } diff --git a/testutils/flagv1/flag_data.go b/testutils/flagv1/flag_data.go index 83f43ec9543..5dfa55b1fa1 100644 --- a/testutils/flagv1/flag_data.go +++ b/testutils/flagv1/flag_data.go @@ -203,9 +203,6 @@ func (f *FlagData) getActualPercentage() float64 { if now.Before(*f.Rollout.Progressive.ReleaseRamp.Start) { return initialPercentage } - if now.After(*f.Rollout.Progressive.ReleaseRamp.End) { - return endPercentage - } // during the rollout ramp we compute the percentage nbSec := f.Rollout.Progressive.ReleaseRamp.End.Unix() - f.Rollout.Progressive.ReleaseRamp.Start.Unix() From 429141e80acacb9f30a2fb5f2f6ce88eee9d98cb Mon Sep 17 00:00:00 2001 From: Thomas Poignant Date: Mon, 8 Aug 2022 01:36:12 +0200 Subject: [PATCH 22/50] adding field Signed-off-by: Thomas Poignant --- .../testdata/should_call_webhook_and_have_valid_results.json | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/notifier/slacknotifier/testdata/should_call_webhook_and_have_valid_results.json b/notifier/slacknotifier/testdata/should_call_webhook_and_have_valid_results.json index acc131482dd..a7de0f6fad6 100644 --- a/notifier/slacknotifier/testdata/should_call_webhook_and_have_valid_results.json +++ b/notifier/slacknotifier/testdata/should_call_webhook_and_have_valid_results.json @@ -35,7 +35,7 @@ }, { "title": "Rules", - "value": "nil =\u003e (*[]flag.Rule){flag.Rule{Name:(*string)(\"legacyRuleV0\"), Query:(*string)(\"key eq \\\"not-a-ke\\\"\"), VariationResult:(*string)(nil), Percentages:(*map[string]float64){\"False\":20, \"True\":80}, ProgressiveRollout:(*flag.ProgressiveRollout)(nil)}}", + "value": "nil =\u003e (*[]flag.Rule){flag.Rule{Name:(*string)(\"legacyRuleV0\"), Query:(*string)(\"key eq \\\"not-a-ke\\\"\"), VariationResult:(*string)(nil), Percentages:(*map[string]float64){\"False\":20, \"True\":80}, ProgressiveRollout:(*flag.ProgressiveRollout)(nil), Disable:(*bool)(nil)}}", "short": false }, { From d394e8433ffab86a2067c0f665b8a03ea4193110 Mon Sep 17 00:00:00 2001 From: Thomas Poignant Date: Mon, 8 Aug 2022 01:44:42 +0200 Subject: [PATCH 23/50] remove method string from the flag contract Signed-off-by: Thomas Poignant --- internal/flag/flag.go | 3 --- internal/flag/internal_flag.go | 4 ---- 2 files changed, 7 deletions(-) diff --git a/internal/flag/flag.go b/internal/flag/flag.go index c830f5e6aef..19ef153a64b 100644 --- a/internal/flag/flag.go +++ b/internal/flag/flag.go @@ -8,9 +8,6 @@ type Flag interface { // Value is returning the Value associate to the flag (True / False / Default ) Value(flagName string, user ffuser.User, evaluationCtx EvaluationContext) (interface{}, ResolutionDetails) - // String display correctly a flag with the right formatting - String() string - // GetVersion is the getter for the field Version // Default: 0.0 GetVersion() string diff --git a/internal/flag/internal_flag.go b/internal/flag/internal_flag.go index e099fa0b44f..4f26a9921dc 100644 --- a/internal/flag/internal_flag.go +++ b/internal/flag/internal_flag.go @@ -46,10 +46,6 @@ type InternalFlag struct { Version *string `json:"version,omitempty" yaml:"version,omitempty" toml:"version,omitempty"` } -func (f *InternalFlag) String() string { - panic("implement me") -} - // Value is returning the Value associate to the flag func (f *InternalFlag) Value( flagName string, From 48d01875791f153c52dc2092d288f6d8e5319e1a Mon Sep 17 00:00:00 2001 From: Thomas Poignant Date: Mon, 8 Aug 2022 15:05:11 +0200 Subject: [PATCH 24/50] Adding more test for internal flag Signed-off-by: Thomas Poignant --- internal/flag/internal_flag.go | 5 -- internal/flag/internal_flag_test.go | 133 ++++++++++++++++++++++++++++ 2 files changed, 133 insertions(+), 5 deletions(-) diff --git a/internal/flag/internal_flag.go b/internal/flag/internal_flag.go index 4f26a9921dc..d88d7808f2e 100644 --- a/internal/flag/internal_flag.go +++ b/internal/flag/internal_flag.go @@ -222,11 +222,6 @@ func (f *InternalFlag) GetVersion() string { return *f.Version } -// GetRollout is the getter for the field Rollout -func (f *InternalFlag) GetRollout() *Rollout { - return f.Rollout -} - // GetVariationValue return the value of variation from his name func (f *InternalFlag) GetVariationValue(name string) interface{} { for k, v := range f.GetVariations() { diff --git a/internal/flag/internal_flag_test.go b/internal/flag/internal_flag_test.go index 19bd7e74bb3..834a4cf4569 100644 --- a/internal/flag/internal_flag_test.go +++ b/internal/flag/internal_flag_test.go @@ -990,3 +990,136 @@ func TestFlag_ProgressiveRollout(t *testing.T) { v3, _ := f.Value(flagName, user, flag.EvaluationContext{}) assert.Equal(t, f.GetVariationValue("variation_B"), v3) } + +func TestInternalFlag_GetVariations(t *testing.T) { + tests := []struct { + name string + flag flag.InternalFlag + want map[string]*interface{} + }{ + { + name: "Should return empty map if variations nil", + flag: flag.InternalFlag{Variations: nil}, + want: map[string]*interface{}{}, + }, + { + name: "Should return empty map if variations empty map", + flag: flag.InternalFlag{ + Variations: &map[string]*interface{}{}, + }, + want: map[string]*interface{}{}, + }, + { + name: "Should return variations if map is not empty", + flag: flag.InternalFlag{ + Variations: &map[string]*interface{}{ + "varA": testconvert.Interface("valueA"), + "varB": testconvert.Interface("valueB"), + }, + }, + want: map[string]*interface{}{ + "varA": testconvert.Interface("valueA"), + "varB": testconvert.Interface("valueB"), + }, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + assert.Equalf(t, tt.want, tt.flag.GetVariations(), "GetVariations()") + }) + } +} + +func TestInternalFlag_GetRuleIndexByName(t *testing.T) { + tests := []struct { + name string + flag flag.InternalFlag + ruleName string + want *int + }{ + { + name: "Should return nil if no rules in flag", + flag: flag.InternalFlag{ + Rules: nil, + }, + ruleName: "rule1", + want: nil, + }, + { + name: "Should return nil if empty slide of rule", + flag: flag.InternalFlag{ + Rules: &[]flag.Rule{}, + }, + ruleName: "rule1", + want: nil, + }, + { + name: "Should return nil if empty slide of rule", + flag: flag.InternalFlag{ + Rules: &[]flag.Rule{ + { + Name: testconvert.String("rule0"), + }, + { + Name: testconvert.String("rule1"), + }, + }, + }, + ruleName: "rule1", + want: testconvert.Int(1), + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + assert.Equalf(t, tt.want, tt.flag.GetRuleIndexByName(tt.ruleName), "GetRuleIndexByName(%v)", tt.ruleName) + }) + } +} + +func TestInternalFlag_GetVariationValue(t *testing.T) { + tests := []struct { + name string + flag flag.InternalFlag + variation string + want interface{} + }{ + { + name: "Should return nil if variation does not exists", + flag: flag.InternalFlag{ + Variations: &map[string]*interface{}{ + "varA": testconvert.Interface("valueA"), + "varB": testconvert.Interface("valueB"), + }, + }, + variation: "varC", + want: nil, + }, + { + name: "Should return variation value if exists", + flag: flag.InternalFlag{ + Variations: &map[string]*interface{}{ + "varA": testconvert.Interface("valueA"), + "varB": testconvert.Interface("valueB"), + }, + }, + variation: "varA", + want: "valueA", + }, + { + name: "Should return nil if variation value is nil", + flag: flag.InternalFlag{ + Variations: &map[string]*interface{}{ + "varA": testconvert.Interface(nil), + "varB": testconvert.Interface("valueB"), + }, + }, + variation: "varA", + want: nil, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + assert.Equalf(t, tt.want, tt.flag.GetVariationValue(tt.variation), "GetVariationValue(%v)", tt.variation) + }) + } +} From cb85346988b833878194c67bb221ba6bcd41cc76 Mon Sep 17 00:00:00 2001 From: Thomas Poignant Date: Mon, 8 Aug 2022 15:28:28 +0200 Subject: [PATCH 25/50] Stop using DTOv0 directly Signed-off-by: Thomas Poignant --- internal/dto/converter_v0.go | 76 ++++---- internal/dto/converter_v0_test.go | 290 +++++++++++++++--------------- internal/dto/dto.go | 48 +++-- internal/dto/rollout_v0.go | 4 +- testutils/flagv1/convert.go | 40 ++--- testutils/flagv1/flag_data.go | 4 +- 6 files changed, 245 insertions(+), 217 deletions(-) diff --git a/internal/dto/converter_v0.go b/internal/dto/converter_v0.go index cfa7e396524..b874de8946e 100644 --- a/internal/dto/converter_v0.go +++ b/internal/dto/converter_v0.go @@ -21,7 +21,7 @@ var ( // ConvertV0DtoToInternalFlag is converting a flag in the config file to the internal format. // this function convert only the old format of the flag (before v1.0.0), to keep // backward support of the configurations. -func ConvertV0DtoToInternalFlag(d DTOv0, isScheduledStep bool) flag.InternalFlag { +func ConvertV0DtoToInternalFlag(d DTO, isScheduledStep bool) flag.InternalFlag { // Create variations based on the available definition in the flag v0 var variations *map[string]*interface{} newVariations := createVariationsV0(d, isScheduledStep) @@ -49,7 +49,7 @@ func ConvertV0DtoToInternalFlag(d DTOv0, isScheduledStep bool) flag.InternalFlag } var rollout *flag.Rollout - if d.Rollout != nil && (d.Rollout.Experimentation != nil || d.Rollout.Scheduled != nil) { + if d.RolloutV0 != nil && (d.RolloutV0.Experimentation != nil || d.RolloutV0.Scheduled != nil) { rollout = convertRollout(d, internalFlag) } @@ -58,11 +58,11 @@ func ConvertV0DtoToInternalFlag(d DTOv0, isScheduledStep bool) flag.InternalFlag } // createDefaultLegacyRuleV0 create the default rule based on the legacy format. -func createDefaultLegacyRuleV0(d DTOv0, hasTargetRule bool) *flag.Rule { - hasProgressiveRollout := d.Rollout != nil && - d.Rollout.Progressive != nil && - d.Rollout.Progressive.ReleaseRamp.Start != nil && - d.Rollout.Progressive.ReleaseRamp.End != nil +func createDefaultLegacyRuleV0(d DTO, hasTargetRule bool) *flag.Rule { + hasProgressiveRollout := d.RolloutV0 != nil && + d.RolloutV0.Progressive != nil && + d.RolloutV0.Progressive.ReleaseRamp.Start != nil && + d.RolloutV0.Progressive.ReleaseRamp.End != nil if hasProgressiveRollout && !hasTargetRule { return &flag.Rule{ @@ -70,13 +70,13 @@ func createDefaultLegacyRuleV0(d DTOv0, hasTargetRule bool) *flag.Rule { ProgressiveRollout: &flag.ProgressiveRollout{ Initial: &flag.ProgressiveRolloutStep{ Variation: &falseVariation, - Percentage: &d.Rollout.Progressive.Percentage.Initial, - Date: d.Rollout.Progressive.ReleaseRamp.Start, + Percentage: &d.RolloutV0.Progressive.Percentage.Initial, + Date: d.RolloutV0.Progressive.ReleaseRamp.Start, }, End: &flag.ProgressiveRolloutStep{ Variation: &trueVariation, - Percentage: &d.Rollout.Progressive.Percentage.End, - Date: d.Rollout.Progressive.ReleaseRamp.End, + Percentage: &d.RolloutV0.Progressive.Percentage.End, + Date: d.RolloutV0.Progressive.ReleaseRamp.End, }, }, } @@ -103,23 +103,23 @@ func createDefaultLegacyRuleV0(d DTOv0, hasTargetRule bool) *flag.Rule { } // createLegacyRuleV0 will create a rule based on the previous format -func createLegacyRuleV0(d DTOv0) flag.Rule { +func createLegacyRuleV0(d DTO) flag.Rule { // Handle the specific use case of progressive rollout. var progressiveRollout *flag.ProgressiveRollout - if d.Rollout != nil && - d.Rollout.Progressive != nil && - d.Rollout.Progressive.ReleaseRamp.Start != nil && - d.Rollout.Progressive.ReleaseRamp.End != nil { + if d.RolloutV0 != nil && + d.RolloutV0.Progressive != nil && + d.RolloutV0.Progressive.ReleaseRamp.Start != nil && + d.RolloutV0.Progressive.ReleaseRamp.End != nil { progressiveRollout = &flag.ProgressiveRollout{ Initial: &flag.ProgressiveRolloutStep{ Variation: &falseVariation, - Percentage: &d.Rollout.Progressive.Percentage.Initial, - Date: d.Rollout.Progressive.ReleaseRamp.Start, + Percentage: &d.RolloutV0.Progressive.Percentage.Initial, + Date: d.RolloutV0.Progressive.ReleaseRamp.Start, }, End: &flag.ProgressiveRolloutStep{ Variation: &trueVariation, - Percentage: &d.Rollout.Progressive.Percentage.End, - Date: d.Rollout.Progressive.ReleaseRamp.End, + Percentage: &d.RolloutV0.Progressive.Percentage.End, + Date: d.RolloutV0.Progressive.ReleaseRamp.End, }, } } @@ -145,7 +145,7 @@ func createLegacyRuleV0(d DTOv0) flag.Rule { } // createVariationsV0 will create a set of variations based on the previous format -func createVariationsV0(d DTOv0, isScheduleStep bool) *map[string]*interface{} { +func createVariationsV0(d DTO, isScheduleStep bool) *map[string]*interface{} { variations := make(map[string]*interface{}, 3) if d.True != nil { variations[trueVariation] = d.True @@ -171,7 +171,7 @@ func createScheduledStep(f flag.InternalFlag, dto ScheduledStepV0) flag.Schedule step := flag.ScheduledStep{ Date: dto.Date, InternalFlag: flag.InternalFlag{ - Variations: createVariationsV0(dto.DTOv0, true), + Variations: createVariationsV0(dto.DTO, true), }, } @@ -260,21 +260,21 @@ func createScheduledStep(f flag.InternalFlag, dto ScheduledStepV0) flag.Schedule return step } -func convertRollout(dto DTOv0, f flag.InternalFlag) *flag.Rollout { +func convertRollout(dto DTO, f flag.InternalFlag) *flag.Rollout { r := flag.Rollout{} - if dto.Rollout.Experimentation != nil && - dto.Rollout.Experimentation.Start != nil && - dto.Rollout.Experimentation.End != nil { + if dto.RolloutV0.Experimentation != nil && + dto.RolloutV0.Experimentation.Start != nil && + dto.RolloutV0.Experimentation.End != nil { r.Experimentation = &flag.ExperimentationRollout{ - Start: dto.Rollout.Experimentation.Start, - End: dto.Rollout.Experimentation.End, + Start: dto.RolloutV0.Experimentation.Start, + End: dto.RolloutV0.Experimentation.End, } } // it is not allowed to have a scheduled step inside a scheduled step - if dto.Rollout.Scheduled != nil && dto.Rollout.Scheduled.Steps != nil { + if dto.RolloutV0.Scheduled != nil && dto.RolloutV0.Scheduled.Steps != nil { var convertedSteps []flag.ScheduledStep - for _, v := range dto.Rollout.Scheduled.Steps { + for _, v := range dto.RolloutV0.Scheduled.Steps { convertedSteps = append(convertedSteps, createScheduledStep(f, v)) } r.Scheduled = &convertedSteps @@ -304,23 +304,23 @@ func deepCopyPercentages(in map[string]float64) *map[string]float64 { // convertProgressiveRollout convert the legacy format to the new format. // If we can't convert we return a nil value. func convertScheduledStepProgressiveRollout(dto ScheduledStepV0) *flag.ProgressiveRollout { - hasProgressiveRollout := dto.Rollout != nil && - dto.Rollout.Progressive != nil && - dto.Rollout.Progressive.ReleaseRamp.End != nil && - dto.Rollout.Progressive.ReleaseRamp.Start != nil + hasProgressiveRollout := dto.RolloutV0 != nil && + dto.RolloutV0.Progressive != nil && + dto.RolloutV0.Progressive.ReleaseRamp.End != nil && + dto.RolloutV0.Progressive.ReleaseRamp.Start != nil var progressive *flag.ProgressiveRollout if hasProgressiveRollout { progressive = &flag.ProgressiveRollout{ Initial: &flag.ProgressiveRolloutStep{ Variation: &falseVariation, - Percentage: &dto.Rollout.Progressive.Percentage.Initial, - Date: dto.Rollout.Progressive.ReleaseRamp.Start, + Percentage: &dto.RolloutV0.Progressive.Percentage.Initial, + Date: dto.RolloutV0.Progressive.ReleaseRamp.Start, }, End: &flag.ProgressiveRolloutStep{ Variation: &trueVariation, - Percentage: &dto.Rollout.Progressive.Percentage.End, - Date: dto.Rollout.Progressive.ReleaseRamp.End, + Percentage: &dto.RolloutV0.Progressive.Percentage.End, + Date: dto.RolloutV0.Progressive.ReleaseRamp.End, }, } } diff --git a/internal/dto/converter_v0_test.go b/internal/dto/converter_v0_test.go index e1efabc3ec9..f71cb29822d 100644 --- a/internal/dto/converter_v0_test.go +++ b/internal/dto/converter_v0_test.go @@ -18,16 +18,16 @@ import ( func TestConvertV0DtoToInternalFlag(t *testing.T) { tests := []struct { name string - d dto.DTOv0 + d dto.DTO want flag.InternalFlag }{ { name: "Simplest flag, no converter provided", - d: dto.DTOv0{ + d: dto.DTO{DTOv0: dto.DTOv0{ True: testconvert.Interface("true"), False: testconvert.Interface("false"), Default: testconvert.Interface("default"), - }, + }}, want: flag.InternalFlag{ Variations: &map[string]*interface{}{ "Default": testconvert.Interface("default"), @@ -46,12 +46,12 @@ func TestConvertV0DtoToInternalFlag(t *testing.T) { }, { name: "Flag with percentage", - d: dto.DTOv0{ + d: dto.DTO{DTOv0: dto.DTOv0{ Percentage: testconvert.Float64(10), True: testconvert.Interface("true"), False: testconvert.Interface("false"), Default: testconvert.Interface("default"), - }, + }}, want: flag.InternalFlag{ Variations: &map[string]*interface{}{ "Default": testconvert.Interface("default"), @@ -69,12 +69,12 @@ func TestConvertV0DtoToInternalFlag(t *testing.T) { }, { name: "Flag with 100 percentage", - d: dto.DTOv0{ + d: dto.DTO{DTOv0: dto.DTOv0{ Percentage: testconvert.Float64(100), True: testconvert.Interface("true"), False: testconvert.Interface("false"), Default: testconvert.Interface("default"), - }, + }}, want: flag.InternalFlag{ Variations: &map[string]*interface{}{ "Default": testconvert.Interface("default"), @@ -93,12 +93,12 @@ func TestConvertV0DtoToInternalFlag(t *testing.T) { }, { name: "Flag with rule not match", - d: dto.DTOv0{ + d: dto.DTO{DTOv0: dto.DTOv0{ Rule: testconvert.String("key eq \"random\""), True: testconvert.Interface("true"), False: testconvert.Interface("false"), Default: testconvert.Interface("default"), - }, + }}, want: flag.InternalFlag{ Variations: &map[string]*interface{}{ "Default": testconvert.Interface("default"), @@ -123,12 +123,12 @@ func TestConvertV0DtoToInternalFlag(t *testing.T) { }, { name: "Flag with rule match", - d: dto.DTOv0{ + d: dto.DTO{DTOv0: dto.DTOv0{ Rule: testconvert.String("key eq \"test-user\""), True: testconvert.Interface("true"), False: testconvert.Interface("false"), Default: testconvert.Interface("default"), - }, + }}, want: flag.InternalFlag{ Variations: &map[string]*interface{}{ "Default": testconvert.Interface("default"), @@ -153,13 +153,13 @@ func TestConvertV0DtoToInternalFlag(t *testing.T) { }, { name: "Flag with rule match + 10% percentage", - d: dto.DTOv0{ + d: dto.DTO{DTOv0: dto.DTOv0{ Rule: testconvert.String("key eq \"test-user\""), Percentage: testconvert.Float64(10), True: testconvert.Interface("true"), False: testconvert.Interface("false"), Default: testconvert.Interface("default"), - }, + }}, want: flag.InternalFlag{ Variations: &map[string]*interface{}{ "Default": testconvert.Interface("default"), @@ -184,19 +184,19 @@ func TestConvertV0DtoToInternalFlag(t *testing.T) { }, { name: "Flag with query + experimentation rollout", - d: dto.DTOv0{ + d: dto.DTO{DTOv0: dto.DTOv0{ Rule: testconvert.String("key eq \"test-user\""), Percentage: testconvert.Float64(100), True: testconvert.Interface("true"), False: testconvert.Interface("false"), Default: testconvert.Interface("default"), - Rollout: &dto.RolloutV0{ + RolloutV0: &dto.RolloutV0{ Experimentation: &dto.ExperimentationV0{ Start: testconvert.Time(time.Date(2021, time.February, 1, 10, 10, 10, 10, time.UTC)), End: testconvert.Time(time.Date(2021, time.February, 2, 10, 10, 10, 10, time.UTC)), }, }, - }, + }}, want: flag.InternalFlag{ Variations: &map[string]*interface{}{ "Default": testconvert.Interface("default"), @@ -227,13 +227,13 @@ func TestConvertV0DtoToInternalFlag(t *testing.T) { }, { name: "Flag with query + progressive rollout", - d: dto.DTOv0{ + d: dto.DTO{DTOv0: dto.DTOv0{ Rule: testconvert.String("key eq \"test-user\""), Percentage: testconvert.Float64(100), True: testconvert.Interface("true"), False: testconvert.Interface("false"), Default: testconvert.Interface("default"), - Rollout: &dto.RolloutV0{ + RolloutV0: &dto.RolloutV0{ Progressive: &dto.ProgressiveV0{ Percentage: dto.ProgressivePercentageV0{ Initial: 0, @@ -245,7 +245,7 @@ func TestConvertV0DtoToInternalFlag(t *testing.T) { }, }, }, - }, + }}, want: flag.InternalFlag{ Variations: &map[string]*interface{}{ "Default": testconvert.Interface("default"), @@ -278,11 +278,11 @@ func TestConvertV0DtoToInternalFlag(t *testing.T) { }, { name: "Flag without query + progressive rollout", - d: dto.DTOv0{ + d: dto.DTO{DTOv0: dto.DTOv0{ True: testconvert.Interface("true"), False: testconvert.Interface("false"), Default: testconvert.Interface("default"), - Rollout: &dto.RolloutV0{ + RolloutV0: &dto.RolloutV0{ Progressive: &dto.ProgressiveV0{ Percentage: dto.ProgressivePercentageV0{ Initial: 0, @@ -294,7 +294,7 @@ func TestConvertV0DtoToInternalFlag(t *testing.T) { }, }, }, - }, + }}, want: flag.InternalFlag{ Variations: &map[string]*interface{}{ "Default": testconvert.Interface("default"), @@ -343,12 +343,12 @@ func TestConvertV0ScheduleStep(t *testing.T) { False: testconvert.Interface("false"), Default: testconvert.Interface("default"), Percentage: testconvert.Float64(95), - Rollout: &dto.RolloutV0{ + RolloutV0: &dto.RolloutV0{ Scheduled: &dto.ScheduledRolloutV0{Steps: []dto.ScheduledStepV0{ { - DTOv0: dto.DTOv0{ + DTO: dto.DTO{DTOv0: dto.DTOv0{ Rule: testconvert.String("anonymous eq false"), - }, + }}, Date: testconvert.Time(time.Now().Add(-2 * time.Second)), }, }}, @@ -365,13 +365,13 @@ func TestConvertV0ScheduleStep(t *testing.T) { False: testconvert.Interface("false"), Default: testconvert.Interface("default"), Percentage: testconvert.Float64(95), - Rollout: &dto.RolloutV0{ + RolloutV0: &dto.RolloutV0{ Scheduled: &dto.ScheduledRolloutV0{Steps: []dto.ScheduledStepV0{ { - DTOv0: dto.DTOv0{ + DTO: dto.DTO{DTOv0: dto.DTOv0{ Rule: testconvert.String("anonymous eq false"), Percentage: testconvert.Float64(5), - }, + }}, Date: testconvert.Time(time.Now().Add(-2 * time.Second)), }, }}, @@ -387,12 +387,12 @@ func TestConvertV0ScheduleStep(t *testing.T) { False: testconvert.Interface("false"), Default: testconvert.Interface("default"), Percentage: testconvert.Float64(100), - Rollout: &dto.RolloutV0{ + RolloutV0: &dto.RolloutV0{ Scheduled: &dto.ScheduledRolloutV0{Steps: []dto.ScheduledStepV0{ { - DTOv0: dto.DTOv0{ + DTO: dto.DTO{DTOv0: dto.DTOv0{ Percentage: testconvert.Float64(10), - }, + }}, Date: testconvert.Time(time.Now().Add(-2 * time.Second)), }, }}, @@ -408,12 +408,12 @@ func TestConvertV0ScheduleStep(t *testing.T) { False: testconvert.Interface("false"), Default: testconvert.Interface("default"), Percentage: testconvert.Float64(100), - Rollout: &dto.RolloutV0{ + RolloutV0: &dto.RolloutV0{ Scheduled: &dto.ScheduledRolloutV0{Steps: []dto.ScheduledStepV0{ { - DTOv0: dto.DTOv0{ + DTO: dto.DTO{DTOv0: dto.DTOv0{ Rule: testconvert.String("key eq \"ko\""), - }, + }}, Date: testconvert.Time(time.Now().Add(-2 * time.Second)), }, }}, @@ -429,12 +429,12 @@ func TestConvertV0ScheduleStep(t *testing.T) { False: testconvert.Interface("false"), Default: testconvert.Interface("default"), Percentage: testconvert.Float64(100), - Rollout: &dto.RolloutV0{ + RolloutV0: &dto.RolloutV0{ Scheduled: &dto.ScheduledRolloutV0{Steps: []dto.ScheduledStepV0{ { - DTOv0: dto.DTOv0{ + DTO: dto.DTO{DTOv0: dto.DTOv0{ Rule: testconvert.String("key eq \"yo\""), - }, + }}, Date: testconvert.Time(time.Now().Add(-2 * time.Second)), }, }}, @@ -450,12 +450,12 @@ func TestConvertV0ScheduleStep(t *testing.T) { False: testconvert.Interface("false"), Default: testconvert.Interface("default"), Percentage: testconvert.Float64(100), - Rollout: &dto.RolloutV0{ + RolloutV0: &dto.RolloutV0{ Scheduled: &dto.ScheduledRolloutV0{Steps: []dto.ScheduledStepV0{ { - DTOv0: dto.DTOv0{ + DTO: dto.DTO{DTOv0: dto.DTOv0{ True: testconvert.Interface("newValue"), - }, + }}, Date: testconvert.Time(time.Now().Add(-2 * time.Second)), }, }}, @@ -471,12 +471,12 @@ func TestConvertV0ScheduleStep(t *testing.T) { False: testconvert.Interface("false"), Default: testconvert.Interface("default"), Percentage: testconvert.Float64(100), - Rollout: &dto.RolloutV0{ + RolloutV0: &dto.RolloutV0{ Scheduled: &dto.ScheduledRolloutV0{Steps: []dto.ScheduledStepV0{ { - DTOv0: dto.DTOv0{ + DTO: dto.DTO{DTOv0: dto.DTOv0{ Percentage: testconvert.Float64(10), - }, + }}, Date: testconvert.Time(time.Now().Add(-2 * time.Second)), }, }}, @@ -492,13 +492,13 @@ func TestConvertV0ScheduleStep(t *testing.T) { False: testconvert.Interface("false"), Default: testconvert.Interface("default"), Percentage: testconvert.Float64(100), - Rollout: &dto.RolloutV0{ + RolloutV0: &dto.RolloutV0{ Scheduled: &dto.ScheduledRolloutV0{Steps: []dto.ScheduledStepV0{ { - DTOv0: dto.DTOv0{ + DTO: dto.DTO{DTOv0: dto.DTOv0{ Rule: testconvert.String("key eq \"yo\""), Percentage: testconvert.Float64(10), - }, + }}, Date: testconvert.Time(time.Now().Add(-2 * time.Second)), }, }}, @@ -514,13 +514,13 @@ func TestConvertV0ScheduleStep(t *testing.T) { False: testconvert.Interface("false"), Default: testconvert.Interface("default"), Percentage: testconvert.Float64(100), - Rollout: &dto.RolloutV0{ + RolloutV0: &dto.RolloutV0{ Scheduled: &dto.ScheduledRolloutV0{Steps: []dto.ScheduledStepV0{ { - DTOv0: dto.DTOv0{ + DTO: dto.DTO{DTOv0: dto.DTOv0{ Rule: testconvert.String("key eq \"yo\""), Percentage: testconvert.Float64(50), - }, + }}, Date: testconvert.Time(time.Now().Add(-2 * time.Second)), }, }}, @@ -537,24 +537,24 @@ func TestConvertV0ScheduleStep(t *testing.T) { Default: testconvert.Interface("default"), Rule: testconvert.String("key eq \"yo\""), Percentage: testconvert.Float64(100), - Rollout: &dto.RolloutV0{ + RolloutV0: &dto.RolloutV0{ Scheduled: &dto.ScheduledRolloutV0{Steps: []dto.ScheduledStepV0{ { - DTOv0: dto.DTOv0{ + DTO: dto.DTO{DTOv0: dto.DTOv0{ Rule: testconvert.String("key eq \"yo\""), - }, + }}, Date: testconvert.Time(time.Now().Add(-2 * time.Second)), }, { - DTOv0: dto.DTOv0{ + DTO: dto.DTO{DTOv0: dto.DTOv0{ Rule: testconvert.String(""), - }, + }}, Date: testconvert.Time(time.Now().Add(-2 * time.Second)), }, { - DTOv0: dto.DTOv0{ + DTO: dto.DTO{DTOv0: dto.DTOv0{ Percentage: testconvert.Float64(10), - }, + }}, Date: testconvert.Time(time.Now().Add(-2 * time.Second)), }, }}, @@ -571,12 +571,12 @@ func TestConvertV0ScheduleStep(t *testing.T) { Default: testconvert.Interface("default"), Rule: testconvert.String("key eq \"yo\""), Percentage: testconvert.Float64(95), - Rollout: &dto.RolloutV0{ + RolloutV0: &dto.RolloutV0{ Scheduled: &dto.ScheduledRolloutV0{Steps: []dto.ScheduledStepV0{ { - DTOv0: dto.DTOv0{ + DTO: dto.DTO{DTOv0: dto.DTOv0{ Rule: testconvert.String(""), - }, + }}, Date: testconvert.Time(time.Now().Add(-2 * time.Second)), }, }}, @@ -593,12 +593,12 @@ func TestConvertV0ScheduleStep(t *testing.T) { Default: testconvert.Interface("default"), Rule: testconvert.String("key eq \"yo\""), Percentage: testconvert.Float64(95), - Rollout: &dto.RolloutV0{ + RolloutV0: &dto.RolloutV0{ Scheduled: &dto.ScheduledRolloutV0{Steps: []dto.ScheduledStepV0{ { - DTOv0: dto.DTOv0{ + DTO: dto.DTO{DTOv0: dto.DTOv0{ Rule: testconvert.String(""), - }, + }}, Date: testconvert.Time(time.Now().Add(-2 * time.Second)), }, }}, @@ -615,11 +615,11 @@ func TestConvertV0ScheduleStep(t *testing.T) { Default: testconvert.Interface("default"), Rule: testconvert.String("key eq \"yo\""), Percentage: testconvert.Float64(0), - Rollout: &dto.RolloutV0{ + RolloutV0: &dto.RolloutV0{ Scheduled: &dto.ScheduledRolloutV0{Steps: []dto.ScheduledStepV0{ { - DTOv0: dto.DTOv0{ - Rollout: &dto.RolloutV0{ + DTO: dto.DTO{DTOv0: dto.DTOv0{ + RolloutV0: &dto.RolloutV0{ Progressive: &dto.ProgressiveV0{ Percentage: dto.ProgressivePercentageV0{ Initial: 0, @@ -631,7 +631,7 @@ func TestConvertV0ScheduleStep(t *testing.T) { }, }, }, - }, + }}, Date: testconvert.Time(time.Now().Add(-2 * time.Second)), }, }}, @@ -648,11 +648,11 @@ func TestConvertV0ScheduleStep(t *testing.T) { Default: testconvert.Interface("default"), Rule: testconvert.String("key eq \"yo\""), Percentage: testconvert.Float64(0), - Rollout: &dto.RolloutV0{ + RolloutV0: &dto.RolloutV0{ Scheduled: &dto.ScheduledRolloutV0{Steps: []dto.ScheduledStepV0{ { - DTOv0: dto.DTOv0{ - Rollout: &dto.RolloutV0{ + DTO: dto.DTO{DTOv0: dto.DTOv0{ + RolloutV0: &dto.RolloutV0{ Progressive: &dto.ProgressiveV0{ Percentage: dto.ProgressivePercentageV0{ Initial: 0, @@ -664,7 +664,7 @@ func TestConvertV0ScheduleStep(t *testing.T) { }, }, }, - }, + }}, Date: testconvert.Time(time.Now().Add(-2 * time.Second)), }, }}, @@ -681,18 +681,18 @@ func TestConvertV0ScheduleStep(t *testing.T) { Default: testconvert.Interface("default"), Rule: testconvert.String("key eq \"yo\""), Percentage: testconvert.Float64(0), - Rollout: &dto.RolloutV0{ + RolloutV0: &dto.RolloutV0{ Scheduled: &dto.ScheduledRolloutV0{Steps: []dto.ScheduledStepV0{ { - DTOv0: dto.DTOv0{ + DTO: dto.DTO{DTOv0: dto.DTOv0{ Percentage: testconvert.Float64(100), - Rollout: &dto.RolloutV0{ + RolloutV0: &dto.RolloutV0{ Experimentation: &dto.ExperimentationV0{ Start: testconvert.Time(time.Now().Add(-1 * time.Second)), End: testconvert.Time(time.Now().Add(600 * time.Second)), }, }, - }, + }}, Date: testconvert.Time(time.Now().Add(-2 * time.Second)), }, }}, @@ -709,72 +709,74 @@ func TestConvertV0ScheduleStep(t *testing.T) { Default: testconvert.Interface("default"), Rule: testconvert.String("key eq \"yo\""), Percentage: testconvert.Float64(100), - Rollout: &dto.RolloutV0{ + RolloutV0: &dto.RolloutV0{ Scheduled: &dto.ScheduledRolloutV0{Steps: []dto.ScheduledStepV0{ { - DTOv0: dto.DTOv0{ + DTO: dto.DTO{DTOv0: dto.DTOv0{ Percentage: testconvert.Float64(10), - }, + }}, Date: testconvert.Time(time.Now().Add(-2 * time.Second)), }, { - DTOv0: dto.DTOv0{ + DTO: dto.DTO{DTOv0: dto.DTOv0{ Rule: testconvert.String("key eq \"yo\""), - }, + }}, Date: testconvert.Time(time.Now().Add(-2 * time.Second)), }, { - DTOv0: dto.DTOv0{ + DTO: dto.DTO{DTOv0: dto.DTOv0{ True: testconvert.Interface("newValue"), - }, + }}, Date: testconvert.Time(time.Now().Add(-2 * time.Second)), }, { - DTOv0: dto.DTOv0{ + DTO: dto.DTO{DTOv0: dto.DTOv0{ Percentage: testconvert.Float64(10), - }, + }}, Date: testconvert.Time(time.Now().Add(-2 * time.Second)), }, { - DTOv0: dto.DTOv0{ + DTO: dto.DTO{DTOv0: dto.DTOv0{ Rule: testconvert.String(""), Percentage: testconvert.Float64(100), - }, + }}, Date: testconvert.Time(time.Now().Add(-2 * time.Second)), }, { - DTOv0: dto.DTOv0{ + DTO: dto.DTO{ Disable: testconvert.Bool(true), }, Date: testconvert.Time(time.Now().Add(-2 * time.Second)), }, { - DTOv0: dto.DTOv0{ - Disable: testconvert.Bool(false), - Rule: testconvert.String("anonymous eq false"), - Percentage: testconvert.Float64(100), + DTO: dto.DTO{ + Disable: testconvert.Bool(false), + DTOv0: dto.DTOv0{ + Rule: testconvert.String("anonymous eq false"), + Percentage: testconvert.Float64(100), + }, }, Date: testconvert.Time(time.Now().Add(-2 * time.Second)), }, { - DTOv0: dto.DTOv0{ - Rollout: &dto.RolloutV0{ + DTO: dto.DTO{DTOv0: dto.DTOv0{ + RolloutV0: &dto.RolloutV0{ Experimentation: &dto.ExperimentationV0{ Start: testconvert.Time(time.Now().Add(-2 * time.Second)), End: testconvert.Time(time.Now().Add(2 * time.Second)), }, }, - }, + }}, Date: testconvert.Time(time.Now().Add(-2 * time.Second)), }, { - DTOv0: dto.DTOv0{ - Rollout: &dto.RolloutV0{ + DTO: dto.DTO{DTOv0: dto.DTOv0{ + RolloutV0: &dto.RolloutV0{ Experimentation: &dto.ExperimentationV0{ End: testconvert.Time(time.Now().Add(-2 * time.Second)), }, }, - }, + }}, Date: testconvert.Time(time.Now().Add(-2 * time.Second)), }, }}, @@ -790,13 +792,13 @@ func TestConvertV0ScheduleStep(t *testing.T) { False: testconvert.Interface("false"), Default: testconvert.Interface("default"), Percentage: testconvert.Float64(100), - Rollout: &dto.RolloutV0{ + RolloutV0: &dto.RolloutV0{ Scheduled: &dto.ScheduledRolloutV0{Steps: []dto.ScheduledStepV0{ { - DTOv0: dto.DTOv0{ + DTO: dto.DTO{DTOv0: dto.DTOv0{ Rule: testconvert.String(""), Percentage: testconvert.Float64(95), - }, + }}, Date: testconvert.Time(time.Now().Add(-2 * time.Second)), }, }}, @@ -811,11 +813,11 @@ func TestConvertV0ScheduleStep(t *testing.T) { True: testconvert.Interface("true"), False: testconvert.Interface("false"), Default: testconvert.Interface("default"), - Rollout: &dto.RolloutV0{ + RolloutV0: &dto.RolloutV0{ Scheduled: &dto.ScheduledRolloutV0{Steps: []dto.ScheduledStepV0{ { - DTOv0: dto.DTOv0{ - Rollout: &dto.RolloutV0{ + DTO: dto.DTO{DTOv0: dto.DTOv0{ + RolloutV0: &dto.RolloutV0{ Progressive: &dto.ProgressiveV0{ Percentage: dto.ProgressivePercentageV0{ Initial: 0, @@ -827,7 +829,7 @@ func TestConvertV0ScheduleStep(t *testing.T) { }, }, }, - }, + }}, Date: testconvert.Time(time.Now().Add(-2 * time.Second)), }, }}, @@ -843,22 +845,24 @@ func TestConvertV0ScheduleStep(t *testing.T) { False: testconvert.Interface("false"), Default: testconvert.Interface("default"), Rule: testconvert.String("key eq \"yo\""), - Rollout: &dto.RolloutV0{ + RolloutV0: &dto.RolloutV0{ Scheduled: &dto.ScheduledRolloutV0{Steps: []dto.ScheduledStepV0{ { - DTOv0: dto.DTOv0{ - Rule: testconvert.String("anonymous eq false"), + DTO: dto.DTO{ TrackEvents: testconvert.Bool(true), Version: testconvert.String("1.0.1"), - Rollout: &dto.RolloutV0{ - Progressive: &dto.ProgressiveV0{ - Percentage: dto.ProgressivePercentageV0{ - Initial: 0, - End: 100, - }, - ReleaseRamp: dto.ProgressiveReleaseRampV0{ - Start: testconvert.Time(time.Now().Add(-10 * time.Minute)), - End: testconvert.Time(time.Now().Add(0 * time.Minute)), + DTOv0: dto.DTOv0{ + Rule: testconvert.String("anonymous eq false"), + RolloutV0: &dto.RolloutV0{ + Progressive: &dto.ProgressiveV0{ + Percentage: dto.ProgressivePercentageV0{ + Initial: 0, + End: 100, + }, + ReleaseRamp: dto.ProgressiveReleaseRampV0{ + Start: testconvert.Time(time.Now().Add(-10 * time.Minute)), + End: testconvert.Time(time.Now().Add(0 * time.Minute)), + }, }, }, }, @@ -877,22 +881,25 @@ func TestConvertV0ScheduleStep(t *testing.T) { True: testconvert.Interface("true"), False: testconvert.Interface("false"), Default: testconvert.Interface("default"), - Rollout: &dto.RolloutV0{ + RolloutV0: &dto.RolloutV0{ Scheduled: &dto.ScheduledRolloutV0{Steps: []dto.ScheduledStepV0{ { - DTOv0: dto.DTOv0{ - Rule: testconvert.String("anonymous eq false"), + DTO: dto.DTO{ TrackEvents: testconvert.Bool(true), Version: testconvert.String("1.0.1"), - Rollout: &dto.RolloutV0{ - Progressive: &dto.ProgressiveV0{ - Percentage: dto.ProgressivePercentageV0{ - Initial: 0, - End: 100, - }, - ReleaseRamp: dto.ProgressiveReleaseRampV0{ - Start: testconvert.Time(time.Now().Add(-10 * time.Minute)), - End: testconvert.Time(time.Now().Add(0 * time.Minute)), + DTOv0: dto.DTOv0{ + Rule: testconvert.String("anonymous eq false"), + + RolloutV0: &dto.RolloutV0{ + Progressive: &dto.ProgressiveV0{ + Percentage: dto.ProgressivePercentageV0{ + Initial: 0, + End: 100, + }, + ReleaseRamp: dto.ProgressiveReleaseRampV0{ + Start: testconvert.Time(time.Now().Add(-10 * time.Minute)), + End: testconvert.Time(time.Now().Add(0 * time.Minute)), + }, }, }, }, @@ -911,22 +918,25 @@ func TestConvertV0ScheduleStep(t *testing.T) { True: testconvert.Interface("true"), False: testconvert.Interface("false"), Default: testconvert.Interface("default"), - Rollout: &dto.RolloutV0{ + RolloutV0: &dto.RolloutV0{ Scheduled: &dto.ScheduledRolloutV0{Steps: []dto.ScheduledStepV0{ { - DTOv0: dto.DTOv0{ - Rule: testconvert.String(""), + DTO: dto.DTO{ TrackEvents: testconvert.Bool(true), Version: testconvert.String("1.0.1"), - Rollout: &dto.RolloutV0{ - Progressive: &dto.ProgressiveV0{ - Percentage: dto.ProgressivePercentageV0{ - Initial: 0, - End: 100, - }, - ReleaseRamp: dto.ProgressiveReleaseRampV0{ - Start: testconvert.Time(time.Now().Add(-10 * time.Minute)), - End: testconvert.Time(time.Now().Add(0 * time.Minute)), + DTOv0: dto.DTOv0{ + Rule: testconvert.String(""), + + RolloutV0: &dto.RolloutV0{ + Progressive: &dto.ProgressiveV0{ + Percentage: dto.ProgressivePercentageV0{ + Initial: 0, + End: 100, + }, + ReleaseRamp: dto.ProgressiveReleaseRampV0{ + Start: testconvert.Time(time.Now().Add(-10 * time.Minute)), + End: testconvert.Time(time.Now().Add(0 * time.Minute)), + }, }, }, }, @@ -947,7 +957,7 @@ func TestConvertV0ScheduleStep(t *testing.T) { convertInternalFlag := tt.dto.Convert() gotInternalFlag, resolutionDetails := convertInternalFlag.Value(flagName, u, flag.EvaluationContext{}) - convertFlagv1 := flagv1.ConvertDtoToV1(tt.dto.DTOv0) + convertFlagv1 := flagv1.ConvertDtoToV1(tt.dto) gotFlagV1, resolutionDetails1 := convertFlagv1.Value(flagName, u, flag.EvaluationContext{}) fmt.Println(gotFlagV1, gotInternalFlag) diff --git a/internal/dto/dto.go b/internal/dto/dto.go index 401d8aae3fd..6a31bc65766 100644 --- a/internal/dto/dto.go +++ b/internal/dto/dto.go @@ -7,11 +7,41 @@ import ( // DTO is representing all the fields we can have in a flag. // This DTO supports all flag formats and convert them into an InternalFlag using a converter. type DTO struct { + DTOv1 `json:",inline" yaml:",inline" toml:",inline"` DTOv0 `json:",inline" yaml:",inline" toml:",inline"` + + // TrackEvents is false if you don't want to export the data in your data exporter. + // Default value is true + TrackEvents *bool `json:"trackEvents,omitempty" yaml:"trackEvents,omitempty" toml:"trackEvents,omitempty"` + + // Disable is true if the flag is disabled. + Disable *bool `json:"disable,omitempty" yaml:"disable,omitempty" toml:"disable,omitempty"` + + // Version (optional) This field contains the version of the flag. + // The version is manually managed when you configure your flags and, it is used to display the information + // in the notifications and data collection. + Version *string `json:"version,omitempty" yaml:"version,omitempty" toml:"version,omitempty"` + // Converter (optional) is the name of converter to use, if no converter specified we try to determine // which converter to use based on the fields we receive for the flag Converter *string `json:"converter,omitempty" yaml:"converter,omitempty" toml:"converter,omitempty"` } +type DTOv1 struct { + // Variations are all the variations available for this flag. The minimum is 2 variations and, we don't have any max + // limit except if the variationValue is a bool, the max is 2. + Variations *map[string]*interface{} `json:"variations,omitempty" yaml:"variations,omitempty" toml:"variations,omitempty"` // nolint:lll + + // Rules is the list of Rule for this flag. + // This an optional field. + Rules *[]flag.Rule `json:"targeting,omitempty" yaml:"targeting,omitempty" toml:"targeting,omitempty"` + + // DefaultRule is the originalRule applied after checking that any other rules + // matched the user. + DefaultRule *flag.Rule `json:"defaultRule,omitempty" yaml:"defaultRule,omitempty" toml:"defaultRule,omitempty"` + + // Rollout is how we roll out the flag + Rollout *flag.Rollout `json:"rollout2,omitempty" yaml:"rollout2,omitempty" toml:"rollout2,omitempty"` +} // DTOv0 describe the fields of a flag. type DTOv0 struct { @@ -35,23 +65,11 @@ type DTOv0 struct { // Default is the value return by the flag if not apply to the user (rule is evaluated to false). Default *interface{} `json:"default,omitempty" yaml:"default,omitempty" toml:"default,omitempty"` - // TrackEvents is false if you don't want to export the data in your data exporter. - // Default value is true - TrackEvents *bool `json:"trackEvents,omitempty" yaml:"trackEvents,omitempty" toml:"trackEvents,omitempty"` - - // Disable is true if the flag is disabled. - Disable *bool `json:"disable,omitempty" yaml:"disable,omitempty" toml:"disable,omitempty"` - - // Rollout is the object to configure how the flag is rolled out. + // RolloutV0 is the object to configure how the flag is rolled out. // You have different rollout strategy available but only one is used at a time. - Rollout *RolloutV0 `json:"rollout,omitempty" yaml:"rollout,omitempty" toml:"rollout,omitempty"` - - // Version (optional) This field contains the version of the flag. - // The version is manually managed when you configure your flags and, it is used to display the information - // in the notifications and data collection. - Version *string `json:"version,omitempty" yaml:"version,omitempty" toml:"version,omitempty"` + RolloutV0 *RolloutV0 `json:"rollout,omitempty" yaml:"rollout,omitempty" toml:"rollout,omitempty"` } func (d *DTO) Convert() flag.InternalFlag { - return ConvertV0DtoToInternalFlag(d.DTOv0, false) + return ConvertV0DtoToInternalFlag(*d, false) } diff --git a/internal/dto/rollout_v0.go b/internal/dto/rollout_v0.go index 18fbe143ad5..5ca1c469a7b 100644 --- a/internal/dto/rollout_v0.go +++ b/internal/dto/rollout_v0.go @@ -67,6 +67,6 @@ type ScheduledRolloutV0 struct { } type ScheduledStepV0 struct { - DTOv0 `yaml:",inline"` - Date *time.Time `json:"date,omitempty" yaml:"date,omitempty" toml:"date,omitempty"` + DTO `yaml:",inline"` + Date *time.Time `json:"date,omitempty" yaml:"date,omitempty" toml:"date,omitempty"` } diff --git a/testutils/flagv1/convert.go b/testutils/flagv1/convert.go index c89f5fa57a1..ae67b4fc129 100644 --- a/testutils/flagv1/convert.go +++ b/testutils/flagv1/convert.go @@ -2,25 +2,25 @@ package flagv1 import "github.com/thomaspoignant/go-feature-flag/internal/dto" -func ConvertDtoToV1(d dto.DTOv0) FlagData { +func ConvertDtoToV1(d dto.DTO) FlagData { var r Rollout - if d.Rollout != nil { + if d.RolloutV0 != nil { r = Rollout{} - if d.Rollout.Progressive != nil { + if d.RolloutV0.Progressive != nil { r.Progressive = &Progressive{} - r.Progressive.ReleaseRamp.Start = d.Rollout.Progressive.ReleaseRamp.Start - r.Progressive.ReleaseRamp.End = d.Rollout.Progressive.ReleaseRamp.End - r.Progressive.Percentage.End = d.Rollout.Progressive.Percentage.End - r.Progressive.Percentage.Initial = d.Rollout.Progressive.Percentage.Initial + r.Progressive.ReleaseRamp.Start = d.RolloutV0.Progressive.ReleaseRamp.Start + r.Progressive.ReleaseRamp.End = d.RolloutV0.Progressive.ReleaseRamp.End + r.Progressive.Percentage.End = d.RolloutV0.Progressive.Percentage.End + r.Progressive.Percentage.Initial = d.RolloutV0.Progressive.Percentage.Initial } - if d.Rollout.Scheduled != nil { + if d.RolloutV0.Scheduled != nil { r.Scheduled = &ScheduledRollout{} - if d.Rollout.Scheduled.Steps != nil { + if d.RolloutV0.Scheduled.Steps != nil { r.Scheduled.Steps = []ScheduledStep{} - for _, step := range d.Rollout.Scheduled.Steps { + for _, step := range d.RolloutV0.Scheduled.Steps { f := FlagData{ Rule: step.Rule, Percentage: step.Percentage, @@ -30,16 +30,16 @@ func ConvertDtoToV1(d dto.DTOv0) FlagData { TrackEvents: step.TrackEvents, Disable: step.Disable, } - if step.Rollout != nil && step.Rollout.Progressive != nil { + if step.RolloutV0 != nil && step.RolloutV0.Progressive != nil { f.Rollout = &Rollout{ Progressive: &Progressive{ ReleaseRamp: ProgressiveReleaseRamp{ - Start: step.Rollout.Progressive.ReleaseRamp.Start, - End: step.Rollout.Progressive.ReleaseRamp.End, + Start: step.RolloutV0.Progressive.ReleaseRamp.Start, + End: step.RolloutV0.Progressive.ReleaseRamp.End, }, Percentage: ProgressivePercentage{ - Initial: step.Rollout.Progressive.Percentage.Initial, - End: step.Rollout.Progressive.Percentage.End, + Initial: step.RolloutV0.Progressive.Percentage.Initial, + End: step.RolloutV0.Progressive.Percentage.End, }, }, } @@ -54,13 +54,13 @@ func ConvertDtoToV1(d dto.DTOv0) FlagData { } } - if d.Rollout.Experimentation != nil { + if d.RolloutV0.Experimentation != nil { r.Experimentation = &Experimentation{} - if d.Rollout.Experimentation.Start != nil { - r.Experimentation.Start = d.Rollout.Experimentation.Start + if d.RolloutV0.Experimentation.Start != nil { + r.Experimentation.Start = d.RolloutV0.Experimentation.Start } - if d.Rollout.Experimentation.End != nil { - r.Experimentation.End = d.Rollout.Experimentation.End + if d.RolloutV0.Experimentation.End != nil { + r.Experimentation.End = d.RolloutV0.Experimentation.End } } } diff --git a/testutils/flagv1/flag_data.go b/testutils/flagv1/flag_data.go index 5dfa55b1fa1..da326b59a3f 100644 --- a/testutils/flagv1/flag_data.go +++ b/testutils/flagv1/flag_data.go @@ -362,9 +362,9 @@ func (f *FlagData) GetRawValues() map[string]string { rawValues["Percentage"] = fmt.Sprintf("%.2f", f.getPercentage()) if f.getRollout() == nil { - rawValues["Rollout"] = "" + rawValues["RolloutV0"] = "" } else { - rawValues["Rollout"] = fmt.Sprintf("%v", f.getRollout()) + rawValues["RolloutV0"] = fmt.Sprintf("%v", f.getRollout()) } rawValues["True"] = convertNilEmpty(f.getTrue()) rawValues["False"] = convertNilEmpty(f.getFalse()) From f2e1a4b2c7f4ee2f6043f482594ca1f1c7069f77 Mon Sep 17 00:00:00 2001 From: Thomas Poignant Date: Mon, 8 Aug 2022 23:14:04 +0200 Subject: [PATCH 26/50] Manage to unmarshal multiple fields with same name Signed-off-by: Thomas Poignant --- internal/dto/convert_v1.go | 30 +++ internal/dto/converter_v0.go | 73 +++--- internal/dto/converter_v0_test.go | 350 +++++++++++++++---------- internal/dto/dto.go | 21 +- internal/dto/dto_rollout.go | 73 ++++++ internal/dto/rollout_progressive.go | 14 + internal/dto/rollout_v0.go | 23 +- internal/flag/rollout.go | 2 +- testdata/flag-config-scheduled-v0.yaml | 17 +- testutils/flagv1/convert.go | 39 +-- 10 files changed, 407 insertions(+), 235 deletions(-) create mode 100644 internal/dto/convert_v1.go create mode 100644 internal/dto/dto_rollout.go create mode 100644 internal/dto/rollout_progressive.go diff --git a/internal/dto/convert_v1.go b/internal/dto/convert_v1.go new file mode 100644 index 00000000000..6a6ea5e0494 --- /dev/null +++ b/internal/dto/convert_v1.go @@ -0,0 +1,30 @@ +package dto + +import "github.com/thomaspoignant/go-feature-flag/internal/flag" + +func ConvertV1DtoToInternalFlag(dto DTO) flag.InternalFlag { + var rollout *flag.Rollout + if dto.Rollout != nil { + rollout = &flag.Rollout{} + if dto.Rollout.V1Rollout.Scheduled != nil { + rollout.Scheduled = dto.Rollout.V1Rollout.Scheduled + } + + if dto.Rollout.Experimentation != nil { + rollout.Experimentation = &flag.ExperimentationRollout{ + Start: dto.Rollout.Experimentation.Start, + End: dto.Rollout.Experimentation.End, + } + } + } + + return flag.InternalFlag{ + Variations: dto.Variations, + Rules: dto.Rules, + DefaultRule: dto.DefaultRule, + Rollout: rollout, + TrackEvents: dto.TrackEvents, + Disable: dto.Disable, + Version: dto.Version, + } +} diff --git a/internal/dto/converter_v0.go b/internal/dto/converter_v0.go index b874de8946e..3e881c8a138 100644 --- a/internal/dto/converter_v0.go +++ b/internal/dto/converter_v0.go @@ -49,7 +49,7 @@ func ConvertV0DtoToInternalFlag(d DTO, isScheduledStep bool) flag.InternalFlag { } var rollout *flag.Rollout - if d.RolloutV0 != nil && (d.RolloutV0.Experimentation != nil || d.RolloutV0.Scheduled != nil) { + if d.Rollout != nil && (d.Rollout.Experimentation != nil || d.Rollout.V0Rollout.Scheduled != nil) { rollout = convertRollout(d, internalFlag) } @@ -59,10 +59,10 @@ func ConvertV0DtoToInternalFlag(d DTO, isScheduledStep bool) flag.InternalFlag { // createDefaultLegacyRuleV0 create the default rule based on the legacy format. func createDefaultLegacyRuleV0(d DTO, hasTargetRule bool) *flag.Rule { - hasProgressiveRollout := d.RolloutV0 != nil && - d.RolloutV0.Progressive != nil && - d.RolloutV0.Progressive.ReleaseRamp.Start != nil && - d.RolloutV0.Progressive.ReleaseRamp.End != nil + hasProgressiveRollout := d.Rollout != nil && + d.Rollout.Progressive != nil && + d.Rollout.Progressive.ReleaseRamp.Start != nil && + d.Rollout.Progressive.ReleaseRamp.End != nil if hasProgressiveRollout && !hasTargetRule { return &flag.Rule{ @@ -70,13 +70,13 @@ func createDefaultLegacyRuleV0(d DTO, hasTargetRule bool) *flag.Rule { ProgressiveRollout: &flag.ProgressiveRollout{ Initial: &flag.ProgressiveRolloutStep{ Variation: &falseVariation, - Percentage: &d.RolloutV0.Progressive.Percentage.Initial, - Date: d.RolloutV0.Progressive.ReleaseRamp.Start, + Percentage: &d.Rollout.Progressive.Percentage.Initial, + Date: d.Rollout.Progressive.ReleaseRamp.Start, }, End: &flag.ProgressiveRolloutStep{ Variation: &trueVariation, - Percentage: &d.RolloutV0.Progressive.Percentage.End, - Date: d.RolloutV0.Progressive.ReleaseRamp.End, + Percentage: &d.Rollout.Progressive.Percentage.End, + Date: d.Rollout.Progressive.ReleaseRamp.End, }, }, } @@ -106,20 +106,20 @@ func createDefaultLegacyRuleV0(d DTO, hasTargetRule bool) *flag.Rule { func createLegacyRuleV0(d DTO) flag.Rule { // Handle the specific use case of progressive rollout. var progressiveRollout *flag.ProgressiveRollout - if d.RolloutV0 != nil && - d.RolloutV0.Progressive != nil && - d.RolloutV0.Progressive.ReleaseRamp.Start != nil && - d.RolloutV0.Progressive.ReleaseRamp.End != nil { + if d.Rollout != nil && + d.Rollout.Progressive != nil && + d.Rollout.Progressive.ReleaseRamp.Start != nil && + d.Rollout.Progressive.ReleaseRamp.End != nil { progressiveRollout = &flag.ProgressiveRollout{ Initial: &flag.ProgressiveRolloutStep{ Variation: &falseVariation, - Percentage: &d.RolloutV0.Progressive.Percentage.Initial, - Date: d.RolloutV0.Progressive.ReleaseRamp.Start, + Percentage: &d.Rollout.Progressive.Percentage.Initial, + Date: d.Rollout.Progressive.ReleaseRamp.Start, }, End: &flag.ProgressiveRolloutStep{ Variation: &trueVariation, - Percentage: &d.RolloutV0.Progressive.Percentage.End, - Date: d.RolloutV0.Progressive.ReleaseRamp.End, + Percentage: &d.Rollout.Progressive.Percentage.End, + Date: d.Rollout.Progressive.ReleaseRamp.End, }, } } @@ -262,22 +262,25 @@ func createScheduledStep(f flag.InternalFlag, dto ScheduledStepV0) flag.Schedule func convertRollout(dto DTO, f flag.InternalFlag) *flag.Rollout { r := flag.Rollout{} - if dto.RolloutV0.Experimentation != nil && - dto.RolloutV0.Experimentation.Start != nil && - dto.RolloutV0.Experimentation.End != nil { + if dto.Rollout.Experimentation != nil && + dto.Rollout.Experimentation.Start != nil && + dto.Rollout.Experimentation.End != nil { r.Experimentation = &flag.ExperimentationRollout{ - Start: dto.RolloutV0.Experimentation.Start, - End: dto.RolloutV0.Experimentation.End, + Start: dto.Rollout.Experimentation.Start, + End: dto.Rollout.Experimentation.End, } } // it is not allowed to have a scheduled step inside a scheduled step - if dto.RolloutV0.Scheduled != nil && dto.RolloutV0.Scheduled.Steps != nil { - var convertedSteps []flag.ScheduledStep - for _, v := range dto.RolloutV0.Scheduled.Steps { - convertedSteps = append(convertedSteps, createScheduledStep(f, v)) + if dto.Rollout.V0Rollout.Scheduled != nil { + s := *dto.Rollout.V0Rollout.Scheduled + if s.Steps != nil { + var convertedSteps []flag.ScheduledStep + for _, v := range s.Steps { + convertedSteps = append(convertedSteps, createScheduledStep(f, v)) + } + r.Scheduled = &convertedSteps } - r.Scheduled = &convertedSteps } return &r } @@ -304,23 +307,23 @@ func deepCopyPercentages(in map[string]float64) *map[string]float64 { // convertProgressiveRollout convert the legacy format to the new format. // If we can't convert we return a nil value. func convertScheduledStepProgressiveRollout(dto ScheduledStepV0) *flag.ProgressiveRollout { - hasProgressiveRollout := dto.RolloutV0 != nil && - dto.RolloutV0.Progressive != nil && - dto.RolloutV0.Progressive.ReleaseRamp.End != nil && - dto.RolloutV0.Progressive.ReleaseRamp.Start != nil + hasProgressiveRollout := dto.Rollout != nil && + dto.Rollout.Progressive != nil && + dto.Rollout.Progressive.ReleaseRamp.End != nil && + dto.Rollout.Progressive.ReleaseRamp.Start != nil var progressive *flag.ProgressiveRollout if hasProgressiveRollout { progressive = &flag.ProgressiveRollout{ Initial: &flag.ProgressiveRolloutStep{ Variation: &falseVariation, - Percentage: &dto.RolloutV0.Progressive.Percentage.Initial, - Date: dto.RolloutV0.Progressive.ReleaseRamp.Start, + Percentage: &dto.Rollout.Progressive.Percentage.Initial, + Date: dto.Rollout.Progressive.ReleaseRamp.Start, }, End: &flag.ProgressiveRolloutStep{ Variation: &trueVariation, - Percentage: &dto.RolloutV0.Progressive.Percentage.End, - Date: dto.RolloutV0.Progressive.ReleaseRamp.End, + Percentage: &dto.Rollout.Progressive.Percentage.End, + Date: dto.Rollout.Progressive.ReleaseRamp.End, }, } } diff --git a/internal/dto/converter_v0_test.go b/internal/dto/converter_v0_test.go index f71cb29822d..7ac92f7b5fa 100644 --- a/internal/dto/converter_v0_test.go +++ b/internal/dto/converter_v0_test.go @@ -1,8 +1,6 @@ package dto_test import ( - "encoding/json" - "fmt" "testing" "time" @@ -184,19 +182,23 @@ func TestConvertV0DtoToInternalFlag(t *testing.T) { }, { name: "Flag with query + experimentation rollout", - d: dto.DTO{DTOv0: dto.DTOv0{ - Rule: testconvert.String("key eq \"test-user\""), - Percentage: testconvert.Float64(100), - True: testconvert.Interface("true"), - False: testconvert.Interface("false"), - Default: testconvert.Interface("default"), - RolloutV0: &dto.RolloutV0{ - Experimentation: &dto.ExperimentationV0{ - Start: testconvert.Time(time.Date(2021, time.February, 1, 10, 10, 10, 10, time.UTC)), - End: testconvert.Time(time.Date(2021, time.February, 2, 10, 10, 10, 10, time.UTC)), + d: dto.DTO{ + DTOv0: dto.DTOv0{ + Rule: testconvert.String("key eq \"test-user\""), + Percentage: testconvert.Float64(100), + True: testconvert.Interface("true"), + False: testconvert.Interface("false"), + Default: testconvert.Interface("default"), + }, + Rollout: &dto.Rollout{ + CommonRollout: dto.CommonRollout{ + Experimentation: &dto.ExperimentationDto{ + Start: testconvert.Time(time.Date(2021, time.February, 1, 10, 10, 10, 10, time.UTC)), + End: testconvert.Time(time.Date(2021, time.February, 2, 10, 10, 10, 10, time.UTC)), + }, }, }, - }}, + }, want: flag.InternalFlag{ Variations: &map[string]*interface{}{ "Default": testconvert.Interface("default"), @@ -227,25 +229,29 @@ func TestConvertV0DtoToInternalFlag(t *testing.T) { }, { name: "Flag with query + progressive rollout", - d: dto.DTO{DTOv0: dto.DTOv0{ - Rule: testconvert.String("key eq \"test-user\""), - Percentage: testconvert.Float64(100), - True: testconvert.Interface("true"), - False: testconvert.Interface("false"), - Default: testconvert.Interface("default"), - RolloutV0: &dto.RolloutV0{ - Progressive: &dto.ProgressiveV0{ - Percentage: dto.ProgressivePercentageV0{ - Initial: 0, - End: 100, - }, - ReleaseRamp: dto.ProgressiveReleaseRampV0{ - Start: testconvert.Time(time.Date(2021, time.February, 1, 10, 10, 10, 10, time.UTC)), - End: testconvert.Time(time.Date(2021, time.February, 2, 10, 10, 10, 10, time.UTC)), + d: dto.DTO{ + DTOv0: dto.DTOv0{ + Rule: testconvert.String("key eq \"test-user\""), + Percentage: testconvert.Float64(100), + True: testconvert.Interface("true"), + False: testconvert.Interface("false"), + Default: testconvert.Interface("default"), + }, + Rollout: &dto.Rollout{ + CommonRollout: dto.CommonRollout{ + Progressive: &dto.ProgressiveV0{ + Percentage: dto.ProgressivePercentageV0{ + Initial: 0, + End: 100, + }, + ReleaseRamp: dto.ProgressiveReleaseRampV0{ + Start: testconvert.Time(time.Date(2021, time.February, 1, 10, 10, 10, 10, time.UTC)), + End: testconvert.Time(time.Date(2021, time.February, 2, 10, 10, 10, 10, time.UTC)), + }, }, }, }, - }}, + }, want: flag.InternalFlag{ Variations: &map[string]*interface{}{ "Default": testconvert.Interface("default"), @@ -278,23 +284,27 @@ func TestConvertV0DtoToInternalFlag(t *testing.T) { }, { name: "Flag without query + progressive rollout", - d: dto.DTO{DTOv0: dto.DTOv0{ - True: testconvert.Interface("true"), - False: testconvert.Interface("false"), - Default: testconvert.Interface("default"), - RolloutV0: &dto.RolloutV0{ - Progressive: &dto.ProgressiveV0{ - Percentage: dto.ProgressivePercentageV0{ - Initial: 0, - End: 100, - }, - ReleaseRamp: dto.ProgressiveReleaseRampV0{ - Start: testconvert.Time(time.Date(2021, time.February, 1, 10, 10, 10, 10, time.UTC)), - End: testconvert.Time(time.Date(2021, time.February, 2, 10, 10, 10, 10, time.UTC)), + d: dto.DTO{ + DTOv0: dto.DTOv0{ + True: testconvert.Interface("true"), + False: testconvert.Interface("false"), + Default: testconvert.Interface("default"), + }, + Rollout: &dto.Rollout{ + CommonRollout: dto.CommonRollout{ + Progressive: &dto.ProgressiveV0{ + Percentage: dto.ProgressivePercentageV0{ + Initial: 0, + End: 100, + }, + ReleaseRamp: dto.ProgressiveReleaseRampV0{ + Start: testconvert.Time(time.Date(2021, time.February, 1, 10, 10, 10, 10, time.UTC)), + End: testconvert.Time(time.Date(2021, time.February, 2, 10, 10, 10, 10, time.UTC)), + }, }, }, }, - }}, + }, want: flag.InternalFlag{ Variations: &map[string]*interface{}{ "Default": testconvert.Interface("default"), @@ -321,9 +331,6 @@ func TestConvertV0DtoToInternalFlag(t *testing.T) { } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { - res := dto.ConvertV0DtoToInternalFlag(tt.d, false) - m, _ := json.Marshal(res) - fmt.Println(string(m)) assert.Equal(t, tt.want, dto.ConvertV0DtoToInternalFlag(tt.d, false)) }) } @@ -343,7 +350,9 @@ func TestConvertV0ScheduleStep(t *testing.T) { False: testconvert.Interface("false"), Default: testconvert.Interface("default"), Percentage: testconvert.Float64(95), - RolloutV0: &dto.RolloutV0{ + }, + Rollout: &dto.Rollout{ + V0Rollout: dto.V0Rollout{ Scheduled: &dto.ScheduledRolloutV0{Steps: []dto.ScheduledStepV0{ { DTO: dto.DTO{DTOv0: dto.DTOv0{ @@ -365,7 +374,9 @@ func TestConvertV0ScheduleStep(t *testing.T) { False: testconvert.Interface("false"), Default: testconvert.Interface("default"), Percentage: testconvert.Float64(95), - RolloutV0: &dto.RolloutV0{ + }, + Rollout: &dto.Rollout{ + V0Rollout: dto.V0Rollout{ Scheduled: &dto.ScheduledRolloutV0{Steps: []dto.ScheduledStepV0{ { DTO: dto.DTO{DTOv0: dto.DTOv0{ @@ -387,7 +398,9 @@ func TestConvertV0ScheduleStep(t *testing.T) { False: testconvert.Interface("false"), Default: testconvert.Interface("default"), Percentage: testconvert.Float64(100), - RolloutV0: &dto.RolloutV0{ + }, + Rollout: &dto.Rollout{ + V0Rollout: dto.V0Rollout{ Scheduled: &dto.ScheduledRolloutV0{Steps: []dto.ScheduledStepV0{ { DTO: dto.DTO{DTOv0: dto.DTOv0{ @@ -408,7 +421,9 @@ func TestConvertV0ScheduleStep(t *testing.T) { False: testconvert.Interface("false"), Default: testconvert.Interface("default"), Percentage: testconvert.Float64(100), - RolloutV0: &dto.RolloutV0{ + }, + Rollout: &dto.Rollout{ + V0Rollout: dto.V0Rollout{ Scheduled: &dto.ScheduledRolloutV0{Steps: []dto.ScheduledStepV0{ { DTO: dto.DTO{DTOv0: dto.DTOv0{ @@ -429,7 +444,9 @@ func TestConvertV0ScheduleStep(t *testing.T) { False: testconvert.Interface("false"), Default: testconvert.Interface("default"), Percentage: testconvert.Float64(100), - RolloutV0: &dto.RolloutV0{ + }, + Rollout: &dto.Rollout{ + V0Rollout: dto.V0Rollout{ Scheduled: &dto.ScheduledRolloutV0{Steps: []dto.ScheduledStepV0{ { DTO: dto.DTO{DTOv0: dto.DTOv0{ @@ -450,7 +467,9 @@ func TestConvertV0ScheduleStep(t *testing.T) { False: testconvert.Interface("false"), Default: testconvert.Interface("default"), Percentage: testconvert.Float64(100), - RolloutV0: &dto.RolloutV0{ + }, + Rollout: &dto.Rollout{ + V0Rollout: dto.V0Rollout{ Scheduled: &dto.ScheduledRolloutV0{Steps: []dto.ScheduledStepV0{ { DTO: dto.DTO{DTOv0: dto.DTOv0{ @@ -471,7 +490,9 @@ func TestConvertV0ScheduleStep(t *testing.T) { False: testconvert.Interface("false"), Default: testconvert.Interface("default"), Percentage: testconvert.Float64(100), - RolloutV0: &dto.RolloutV0{ + }, + Rollout: &dto.Rollout{ + V0Rollout: dto.V0Rollout{ Scheduled: &dto.ScheduledRolloutV0{Steps: []dto.ScheduledStepV0{ { DTO: dto.DTO{DTOv0: dto.DTOv0{ @@ -492,7 +513,9 @@ func TestConvertV0ScheduleStep(t *testing.T) { False: testconvert.Interface("false"), Default: testconvert.Interface("default"), Percentage: testconvert.Float64(100), - RolloutV0: &dto.RolloutV0{ + }, + Rollout: &dto.Rollout{ + V0Rollout: dto.V0Rollout{ Scheduled: &dto.ScheduledRolloutV0{Steps: []dto.ScheduledStepV0{ { DTO: dto.DTO{DTOv0: dto.DTOv0{ @@ -514,7 +537,9 @@ func TestConvertV0ScheduleStep(t *testing.T) { False: testconvert.Interface("false"), Default: testconvert.Interface("default"), Percentage: testconvert.Float64(100), - RolloutV0: &dto.RolloutV0{ + }, + Rollout: &dto.Rollout{ + V0Rollout: dto.V0Rollout{ Scheduled: &dto.ScheduledRolloutV0{Steps: []dto.ScheduledStepV0{ { DTO: dto.DTO{DTOv0: dto.DTOv0{ @@ -537,7 +562,9 @@ func TestConvertV0ScheduleStep(t *testing.T) { Default: testconvert.Interface("default"), Rule: testconvert.String("key eq \"yo\""), Percentage: testconvert.Float64(100), - RolloutV0: &dto.RolloutV0{ + }, + Rollout: &dto.Rollout{ + V0Rollout: dto.V0Rollout{ Scheduled: &dto.ScheduledRolloutV0{Steps: []dto.ScheduledStepV0{ { DTO: dto.DTO{DTOv0: dto.DTOv0{ @@ -571,7 +598,9 @@ func TestConvertV0ScheduleStep(t *testing.T) { Default: testconvert.Interface("default"), Rule: testconvert.String("key eq \"yo\""), Percentage: testconvert.Float64(95), - RolloutV0: &dto.RolloutV0{ + }, + Rollout: &dto.Rollout{ + V0Rollout: dto.V0Rollout{ Scheduled: &dto.ScheduledRolloutV0{Steps: []dto.ScheduledStepV0{ { DTO: dto.DTO{DTOv0: dto.DTOv0{ @@ -593,7 +622,9 @@ func TestConvertV0ScheduleStep(t *testing.T) { Default: testconvert.Interface("default"), Rule: testconvert.String("key eq \"yo\""), Percentage: testconvert.Float64(95), - RolloutV0: &dto.RolloutV0{ + }, + Rollout: &dto.Rollout{ + V0Rollout: dto.V0Rollout{ Scheduled: &dto.ScheduledRolloutV0{Steps: []dto.ScheduledStepV0{ { DTO: dto.DTO{DTOv0: dto.DTOv0{ @@ -615,23 +646,27 @@ func TestConvertV0ScheduleStep(t *testing.T) { Default: testconvert.Interface("default"), Rule: testconvert.String("key eq \"yo\""), Percentage: testconvert.Float64(0), - RolloutV0: &dto.RolloutV0{ + }, + Rollout: &dto.Rollout{ + V0Rollout: dto.V0Rollout{ Scheduled: &dto.ScheduledRolloutV0{Steps: []dto.ScheduledStepV0{ { - DTO: dto.DTO{DTOv0: dto.DTOv0{ - RolloutV0: &dto.RolloutV0{ - Progressive: &dto.ProgressiveV0{ - Percentage: dto.ProgressivePercentageV0{ - Initial: 0, - End: 100, - }, - ReleaseRamp: dto.ProgressiveReleaseRampV0{ - Start: testconvert.Time(time.Now().Add(-300 * time.Second)), - End: testconvert.Time(time.Now().Add(-1 * time.Second)), + DTO: dto.DTO{ + Rollout: &dto.Rollout{ + CommonRollout: dto.CommonRollout{ + Progressive: &dto.ProgressiveV0{ + Percentage: dto.ProgressivePercentageV0{ + Initial: 0, + End: 100, + }, + ReleaseRamp: dto.ProgressiveReleaseRampV0{ + Start: testconvert.Time(time.Now().Add(-300 * time.Second)), + End: testconvert.Time(time.Now().Add(-1 * time.Second)), + }, }, }, }, - }}, + }, Date: testconvert.Time(time.Now().Add(-2 * time.Second)), }, }}, @@ -648,23 +683,27 @@ func TestConvertV0ScheduleStep(t *testing.T) { Default: testconvert.Interface("default"), Rule: testconvert.String("key eq \"yo\""), Percentage: testconvert.Float64(0), - RolloutV0: &dto.RolloutV0{ + }, + Rollout: &dto.Rollout{ + V0Rollout: dto.V0Rollout{ Scheduled: &dto.ScheduledRolloutV0{Steps: []dto.ScheduledStepV0{ { - DTO: dto.DTO{DTOv0: dto.DTOv0{ - RolloutV0: &dto.RolloutV0{ - Progressive: &dto.ProgressiveV0{ - Percentage: dto.ProgressivePercentageV0{ - Initial: 0, - End: 100, - }, - ReleaseRamp: dto.ProgressiveReleaseRampV0{ - Start: testconvert.Time(time.Now().Add(-1 * time.Second)), - End: testconvert.Time(time.Now().Add(600 * time.Second)), + DTO: dto.DTO{ + Rollout: &dto.Rollout{ + CommonRollout: dto.CommonRollout{ + Progressive: &dto.ProgressiveV0{ + Percentage: dto.ProgressivePercentageV0{ + Initial: 0, + End: 100, + }, + ReleaseRamp: dto.ProgressiveReleaseRampV0{ + Start: testconvert.Time(time.Now().Add(-1 * time.Second)), + End: testconvert.Time(time.Now().Add(600 * time.Second)), + }, }, }, }, - }}, + }, Date: testconvert.Time(time.Now().Add(-2 * time.Second)), }, }}, @@ -681,18 +720,24 @@ func TestConvertV0ScheduleStep(t *testing.T) { Default: testconvert.Interface("default"), Rule: testconvert.String("key eq \"yo\""), Percentage: testconvert.Float64(0), - RolloutV0: &dto.RolloutV0{ + }, + Rollout: &dto.Rollout{ + V0Rollout: dto.V0Rollout{ Scheduled: &dto.ScheduledRolloutV0{Steps: []dto.ScheduledStepV0{ { - DTO: dto.DTO{DTOv0: dto.DTOv0{ - Percentage: testconvert.Float64(100), - RolloutV0: &dto.RolloutV0{ - Experimentation: &dto.ExperimentationV0{ - Start: testconvert.Time(time.Now().Add(-1 * time.Second)), - End: testconvert.Time(time.Now().Add(600 * time.Second)), + DTO: dto.DTO{ + DTOv0: dto.DTOv0{ + Percentage: testconvert.Float64(100), + }, + Rollout: &dto.Rollout{ + CommonRollout: dto.CommonRollout{ + Experimentation: &dto.ExperimentationDto{ + Start: testconvert.Time(time.Now().Add(-1 * time.Second)), + End: testconvert.Time(time.Now().Add(600 * time.Second)), + }, }, }, - }}, + }, Date: testconvert.Time(time.Now().Add(-2 * time.Second)), }, }}, @@ -709,7 +754,9 @@ func TestConvertV0ScheduleStep(t *testing.T) { Default: testconvert.Interface("default"), Rule: testconvert.String("key eq \"yo\""), Percentage: testconvert.Float64(100), - RolloutV0: &dto.RolloutV0{ + }, + Rollout: &dto.Rollout{ + V0Rollout: dto.V0Rollout{ Scheduled: &dto.ScheduledRolloutV0{Steps: []dto.ScheduledStepV0{ { DTO: dto.DTO{DTOv0: dto.DTOv0{ @@ -759,24 +806,28 @@ func TestConvertV0ScheduleStep(t *testing.T) { Date: testconvert.Time(time.Now().Add(-2 * time.Second)), }, { - DTO: dto.DTO{DTOv0: dto.DTOv0{ - RolloutV0: &dto.RolloutV0{ - Experimentation: &dto.ExperimentationV0{ - Start: testconvert.Time(time.Now().Add(-2 * time.Second)), - End: testconvert.Time(time.Now().Add(2 * time.Second)), + DTO: dto.DTO{ + Rollout: &dto.Rollout{ + CommonRollout: dto.CommonRollout{ + Experimentation: &dto.ExperimentationDto{ + Start: testconvert.Time(time.Now().Add(-2 * time.Second)), + End: testconvert.Time(time.Now().Add(2 * time.Second)), + }, }, }, - }}, + }, Date: testconvert.Time(time.Now().Add(-2 * time.Second)), }, { - DTO: dto.DTO{DTOv0: dto.DTOv0{ - RolloutV0: &dto.RolloutV0{ - Experimentation: &dto.ExperimentationV0{ - End: testconvert.Time(time.Now().Add(-2 * time.Second)), + DTO: dto.DTO{ + Rollout: &dto.Rollout{ + CommonRollout: dto.CommonRollout{ + Experimentation: &dto.ExperimentationDto{ + End: testconvert.Time(time.Now().Add(-2 * time.Second)), + }, }, }, - }}, + }, Date: testconvert.Time(time.Now().Add(-2 * time.Second)), }, }}, @@ -792,7 +843,9 @@ func TestConvertV0ScheduleStep(t *testing.T) { False: testconvert.Interface("false"), Default: testconvert.Interface("default"), Percentage: testconvert.Float64(100), - RolloutV0: &dto.RolloutV0{ + }, + Rollout: &dto.Rollout{ + V0Rollout: dto.V0Rollout{ Scheduled: &dto.ScheduledRolloutV0{Steps: []dto.ScheduledStepV0{ { DTO: dto.DTO{DTOv0: dto.DTOv0{ @@ -813,23 +866,27 @@ func TestConvertV0ScheduleStep(t *testing.T) { True: testconvert.Interface("true"), False: testconvert.Interface("false"), Default: testconvert.Interface("default"), - RolloutV0: &dto.RolloutV0{ + }, + Rollout: &dto.Rollout{ + V0Rollout: dto.V0Rollout{ Scheduled: &dto.ScheduledRolloutV0{Steps: []dto.ScheduledStepV0{ { - DTO: dto.DTO{DTOv0: dto.DTOv0{ - RolloutV0: &dto.RolloutV0{ - Progressive: &dto.ProgressiveV0{ - Percentage: dto.ProgressivePercentageV0{ - Initial: 0, - End: 100, - }, - ReleaseRamp: dto.ProgressiveReleaseRampV0{ - Start: testconvert.Time(time.Now().Add(10 * time.Minute)), - End: testconvert.Time(time.Now().Add(20 * time.Minute)), + DTO: dto.DTO{ + Rollout: &dto.Rollout{ + CommonRollout: dto.CommonRollout{ + Progressive: &dto.ProgressiveV0{ + Percentage: dto.ProgressivePercentageV0{ + Initial: 0, + End: 100, + }, + ReleaseRamp: dto.ProgressiveReleaseRampV0{ + Start: testconvert.Time(time.Now().Add(10 * time.Minute)), + End: testconvert.Time(time.Now().Add(20 * time.Minute)), + }, }, }, }, - }}, + }, Date: testconvert.Time(time.Now().Add(-2 * time.Second)), }, }}, @@ -845,7 +902,9 @@ func TestConvertV0ScheduleStep(t *testing.T) { False: testconvert.Interface("false"), Default: testconvert.Interface("default"), Rule: testconvert.String("key eq \"yo\""), - RolloutV0: &dto.RolloutV0{ + }, + Rollout: &dto.Rollout{ + V0Rollout: dto.V0Rollout{ Scheduled: &dto.ScheduledRolloutV0{Steps: []dto.ScheduledStepV0{ { DTO: dto.DTO{ @@ -853,7 +912,9 @@ func TestConvertV0ScheduleStep(t *testing.T) { Version: testconvert.String("1.0.1"), DTOv0: dto.DTOv0{ Rule: testconvert.String("anonymous eq false"), - RolloutV0: &dto.RolloutV0{ + }, + Rollout: &dto.Rollout{ + CommonRollout: dto.CommonRollout{ Progressive: &dto.ProgressiveV0{ Percentage: dto.ProgressivePercentageV0{ Initial: 0, @@ -881,7 +942,9 @@ func TestConvertV0ScheduleStep(t *testing.T) { True: testconvert.Interface("true"), False: testconvert.Interface("false"), Default: testconvert.Interface("default"), - RolloutV0: &dto.RolloutV0{ + }, + Rollout: &dto.Rollout{ + V0Rollout: dto.V0Rollout{ Scheduled: &dto.ScheduledRolloutV0{Steps: []dto.ScheduledStepV0{ { DTO: dto.DTO{ @@ -889,8 +952,9 @@ func TestConvertV0ScheduleStep(t *testing.T) { Version: testconvert.String("1.0.1"), DTOv0: dto.DTOv0{ Rule: testconvert.String("anonymous eq false"), - - RolloutV0: &dto.RolloutV0{ + }, + Rollout: &dto.Rollout{ + CommonRollout: dto.CommonRollout{ Progressive: &dto.ProgressiveV0{ Percentage: dto.ProgressivePercentageV0{ Initial: 0, @@ -918,32 +982,37 @@ func TestConvertV0ScheduleStep(t *testing.T) { True: testconvert.Interface("true"), False: testconvert.Interface("false"), Default: testconvert.Interface("default"), - RolloutV0: &dto.RolloutV0{ - Scheduled: &dto.ScheduledRolloutV0{Steps: []dto.ScheduledStepV0{ - { - DTO: dto.DTO{ - TrackEvents: testconvert.Bool(true), - Version: testconvert.String("1.0.1"), - DTOv0: dto.DTOv0{ - Rule: testconvert.String(""), - - RolloutV0: &dto.RolloutV0{ - Progressive: &dto.ProgressiveV0{ - Percentage: dto.ProgressivePercentageV0{ - Initial: 0, - End: 100, - }, - ReleaseRamp: dto.ProgressiveReleaseRampV0{ - Start: testconvert.Time(time.Now().Add(-10 * time.Minute)), - End: testconvert.Time(time.Now().Add(0 * time.Minute)), + }, + Rollout: &dto.Rollout{ + V0Rollout: dto.V0Rollout{ + Scheduled: &dto.ScheduledRolloutV0{ + Steps: []dto.ScheduledStepV0{ + { + DTO: dto.DTO{ + TrackEvents: testconvert.Bool(true), + Version: testconvert.String("1.0.1"), + DTOv0: dto.DTOv0{ + Rule: testconvert.String(""), + }, + Rollout: &dto.Rollout{ + CommonRollout: dto.CommonRollout{ + Progressive: &dto.ProgressiveV0{ + Percentage: dto.ProgressivePercentageV0{ + Initial: 0, + End: 100, + }, + ReleaseRamp: dto.ProgressiveReleaseRampV0{ + Start: testconvert.Time(time.Now().Add(-10 * time.Minute)), + End: testconvert.Time(time.Now().Add(0 * time.Minute)), + }, }, }, }, }, + Date: testconvert.Time(time.Now().Add(-2 * time.Second)), }, - Date: testconvert.Time(time.Now().Add(-2 * time.Second)), }, - }}, + }, }, }, }, @@ -960,7 +1029,6 @@ func TestConvertV0ScheduleStep(t *testing.T) { convertFlagv1 := flagv1.ConvertDtoToV1(tt.dto) gotFlagV1, resolutionDetails1 := convertFlagv1.Value(flagName, u, flag.EvaluationContext{}) - fmt.Println(gotFlagV1, gotInternalFlag) assert.Equal(t, gotFlagV1, gotInternalFlag) assert.Equal(t, resolutionDetails.Variant, resolutionDetails1.Variant) assert.Equal(t, resolutionDetails.ErrorCode, resolutionDetails1.ErrorCode) diff --git a/internal/dto/dto.go b/internal/dto/dto.go index 6a31bc65766..f87fe981fb4 100644 --- a/internal/dto/dto.go +++ b/internal/dto/dto.go @@ -25,7 +25,13 @@ type DTO struct { // Converter (optional) is the name of converter to use, if no converter specified we try to determine // which converter to use based on the fields we receive for the flag Converter *string `json:"converter,omitempty" yaml:"converter,omitempty" toml:"converter,omitempty"` + + // Rollout is the object to configure how the flag is rolled out. + // You have different rollout strategy available but only one is used at a time. + Rollout *Rollout `json:"rollout,omitempty" yaml:"rollout,omitempty" toml:"rollout,omitempty"` } + +// DTOv1 is the new format of the flags since version 1.X.X type DTOv1 struct { // Variations are all the variations available for this flag. The minimum is 2 variations and, we don't have any max // limit except if the variationValue is a bool, the max is 2. @@ -38,9 +44,6 @@ type DTOv1 struct { // DefaultRule is the originalRule applied after checking that any other rules // matched the user. DefaultRule *flag.Rule `json:"defaultRule,omitempty" yaml:"defaultRule,omitempty" toml:"defaultRule,omitempty"` - - // Rollout is how we roll out the flag - Rollout *flag.Rollout `json:"rollout2,omitempty" yaml:"rollout2,omitempty" toml:"rollout2,omitempty"` } // DTOv0 describe the fields of a flag. @@ -64,12 +67,14 @@ type DTOv0 struct { // Default is the value return by the flag if not apply to the user (rule is evaluated to false). Default *interface{} `json:"default,omitempty" yaml:"default,omitempty" toml:"default,omitempty"` - - // RolloutV0 is the object to configure how the flag is rolled out. - // You have different rollout strategy available but only one is used at a time. - RolloutV0 *RolloutV0 `json:"rollout,omitempty" yaml:"rollout,omitempty" toml:"rollout,omitempty"` } func (d *DTO) Convert() flag.InternalFlag { - return ConvertV0DtoToInternalFlag(*d, false) + if d == nil { + return flag.InternalFlag{} + } + if (d.Converter != nil && *d.Converter == "v0") || d.True != nil || d.False != nil { + return ConvertV0DtoToInternalFlag(*d, false) + } + return ConvertV1DtoToInternalFlag(*d) } diff --git a/internal/dto/dto_rollout.go b/internal/dto/dto_rollout.go new file mode 100644 index 00000000000..8e36e85ca58 --- /dev/null +++ b/internal/dto/dto_rollout.go @@ -0,0 +1,73 @@ +package dto + +import ( + "encoding/json" + "time" + + "github.com/thomaspoignant/go-feature-flag/internal/flag" +) + +type ExperimentationDto struct { + // Start is the starting time of the experimentation + Start *time.Time `json:"start,omitempty" yaml:"start,omitempty" toml:"start,omitempty"` + + // End is the ending time of the experimentation + End *time.Time `json:"end,omitempty" yaml:"end,omitempty" toml:"end,omitempty"` +} + +type Rollout struct { + // CommonRollout is the struct containing the configuration for rollout that applies for + // all types of flag in your input file. + CommonRollout `json:",inline" yaml:",inline" toml:",inline"` + + // V1Rollout contains the configuration available only for the flags version v1.X.X + V1Rollout `json:",inline" yaml:",inline" toml:",inline"` + + // V0Rollout contains the configuration available only for the flags version v0.X.X + V0Rollout `json:",inline" yaml:",inline" toml:",inline"` // nolint: govet +} + +type CommonRollout struct { + // Experimentation is your struct to configure an experimentation, it will allow you to configure a start date and + // an end date for your flag. + // When the experimentation is not running, the flag will serve the default value. + Experimentation *ExperimentationDto `json:"experimentation,omitempty" yaml:"experimentation,omitempty" toml:"experimentation,omitempty"` // nolint: lll + + // Progressive (only for v0) is your struct to configure a progressive rollout deployment of your flag. + // It will allow you to ramp up the percentage of your flag over time. + // You can decide at which percentage you start and at what percentage you ends in your release ramp. + // Before the start date we will serve the initial percentage and, after we will serve the end percentage. + Progressive *ProgressiveV0 `json:"progressive,omitempty" yaml:"progressive,omitempty" toml:"progressive,omitempty"` // nolint: lll +} + +type V1Rollout struct { + Scheduled *[]flag.ScheduledStep `json:"scheduled,omitempty" yaml:"scheduled,omitempty" toml:"scheduled,omitempty"` // nolint: lll +} + +type V0Rollout struct { + Scheduled *ScheduledRolloutV0 `json:"scheduled,omitempty" yaml:"scheduled,omitempty" toml:"scheduled,omitempty"` // nolint: lll +} + +// UnmarshalJSON is dealing with the fact that we have 2 different entry called scheduled +// in different format, this can cause an issue when unmarshalling the data. +// This is the reason why we have a custom unmarshalling function for this struct. +func (p *Rollout) UnmarshalJSON(data []byte) error { + var c CommonRollout + err := json.Unmarshal(data, &c) + if err != nil { + return err + } + p.CommonRollout = c + + var v1 V1Rollout + // we ignore the unmarshal errors because they are expected since we have multiple format + _ = json.Unmarshal(data, &v1) + p.V1Rollout = v1 + + var v0 V0Rollout + // we ignore the unmarshal errors because they are expected since we have multiple format + _ = json.Unmarshal(data, &v0) + p.V0Rollout = v0 + + return nil +} diff --git a/internal/dto/rollout_progressive.go b/internal/dto/rollout_progressive.go new file mode 100644 index 00000000000..709f101c51c --- /dev/null +++ b/internal/dto/rollout_progressive.go @@ -0,0 +1,14 @@ +package dto + +// ProgressiveV0 is the configuration struct to define a progressive rollout. +type ProgressiveV0 struct { + // Percentage is where you can configure at what percentage your progressive rollout start + // and at what percentage it ends. + // This field is optional + Percentage ProgressivePercentageV0 `json:"percentage,omitempty" yaml:"percentage,omitempty" toml:"percentage,omitempty"` // nolint: lll + + // ReleaseRamp is the defining when the progressive rollout starts and ends. + // This field is mandatory if you want to use a progressive rollout. + // If any field missing we ignore the progressive rollout. + ReleaseRamp ProgressiveReleaseRampV0 `json:"releaseRamp,omitempty" yaml:"releaseRamp,omitempty" toml:"releaseRamp,omitempty"` // nolint: lll +} diff --git a/internal/dto/rollout_v0.go b/internal/dto/rollout_v0.go index 5ca1c469a7b..8fd2ee2ba8c 100644 --- a/internal/dto/rollout_v0.go +++ b/internal/dto/rollout_v0.go @@ -6,7 +6,7 @@ type RolloutV0 struct { // Experimentation is your struct to configure an experimentation, it will allow you to configure a start date and // an end date for your flag. // When the experimentation is not running, the flag will serve the default value. - Experimentation *ExperimentationV0 `json:"experimentation,omitempty" yaml:"experimentation,omitempty" toml:"experimentation,omitempty"` // nolint: lll + Experimentation *ExperimentationDto `json:"experimentation,omitempty" yaml:"experimentation,omitempty" toml:"experimentation,omitempty"` // nolint: lll // Progressive is your struct to configure a progressive rollout deployment of your flag. // It will allow you to ramp up the percentage of your flag over time. @@ -20,27 +20,6 @@ type RolloutV0 struct { Scheduled *ScheduledRolloutV0 `json:"scheduled,omitempty" yaml:"scheduled,omitempty" toml:"scheduled,omitempty"` // nolint: lll } -type ExperimentationV0 struct { - // Start is the starting time of the experimentation - Start *time.Time `json:"start,omitempty" yaml:"start,omitempty" toml:"start,omitempty"` - - // End is the ending time of the experimentation - End *time.Time `json:"end,omitempty" yaml:"end,omitempty" toml:"end,omitempty"` -} - -// ProgressiveV0 is the configuration struct to define a progressive rollout. -type ProgressiveV0 struct { - // Percentage is where you can configure at what percentage your progressive rollout start - // and at what percentage it ends. - // This field is optional - Percentage ProgressivePercentageV0 `json:"percentage,omitempty" yaml:"percentage,omitempty" toml:"percentage,omitempty"` // nolint: lll - - // ReleaseRamp is the defining when the progressive rollout starts and ends. - // This field is mandatory if you want to use a progressive rollout. - // If any field missing we ignore the progressive rollout. - ReleaseRamp ProgressiveReleaseRampV0 `json:"releaseRamp,omitempty" yaml:"releaseRamp,omitempty" toml:"releaseRamp,omitempty"` // nolint: lll -} - type ProgressivePercentageV0 struct { // Initial is the initial percentage before the rollout start date. // This field is optional diff --git a/internal/flag/rollout.go b/internal/flag/rollout.go index e6ea1e9d63f..b9c3d9c2d22 100644 --- a/internal/flag/rollout.go +++ b/internal/flag/rollout.go @@ -9,5 +9,5 @@ type Rollout struct { // Scheduled is your struct to configure an update on some fields of your flag over time. // You can add several steps that updates the flag, this is typically used if you want to gradually add more user // in your flag. - Scheduled *[]ScheduledStep `json:"steps,omitempty" yaml:"steps,omitempty" toml:"steps,omitempty"` + Scheduled *[]ScheduledStep `json:"scheduled,omitempty" yaml:"scheduled,omitempty" toml:"scheduled,omitempty"` } diff --git a/testdata/flag-config-scheduled-v0.yaml b/testdata/flag-config-scheduled-v0.yaml index 111f405cb9e..0bf836ad67e 100644 --- a/testdata/flag-config-scheduled-v0.yaml +++ b/testdata/flag-config-scheduled-v0.yaml @@ -6,17 +6,16 @@ test-flag: default: false rollout: scheduled: - steps: - - date: 2022-08-01T00:00:00.10+02:00 - rule: beta eq "true" - percentage: 100 + - date: 2022-08-01T00:00:00.10+02:00 + rule: beta eq "true" + percentage: 100 - - date: 2022-05-12T15:36:00.10+02:00 - rule: beta eq "false" - percentage: 0 + - date: 2022-05-12T15:36:00.10+02:00 + rule: beta eq "false" + percentage: 0 - - date: 2022-05-12T15:36:00.10+02:00 - rule: "" + - date: 2022-05-12T15:36:00.10+02:00 + rule: "" test-flag2: diff --git a/testutils/flagv1/convert.go b/testutils/flagv1/convert.go index ae67b4fc129..0403f552c5c 100644 --- a/testutils/flagv1/convert.go +++ b/testutils/flagv1/convert.go @@ -5,22 +5,23 @@ import "github.com/thomaspoignant/go-feature-flag/internal/dto" func ConvertDtoToV1(d dto.DTO) FlagData { var r Rollout - if d.RolloutV0 != nil { + if d.Rollout != nil { r = Rollout{} - if d.RolloutV0.Progressive != nil { + if d.Rollout.Progressive != nil { r.Progressive = &Progressive{} - r.Progressive.ReleaseRamp.Start = d.RolloutV0.Progressive.ReleaseRamp.Start - r.Progressive.ReleaseRamp.End = d.RolloutV0.Progressive.ReleaseRamp.End - r.Progressive.Percentage.End = d.RolloutV0.Progressive.Percentage.End - r.Progressive.Percentage.Initial = d.RolloutV0.Progressive.Percentage.Initial + r.Progressive.ReleaseRamp.Start = d.Rollout.Progressive.ReleaseRamp.Start + r.Progressive.ReleaseRamp.End = d.Rollout.Progressive.ReleaseRamp.End + r.Progressive.Percentage.End = d.Rollout.Progressive.Percentage.End + r.Progressive.Percentage.Initial = d.Rollout.Progressive.Percentage.Initial } - if d.RolloutV0.Scheduled != nil { + if d.Rollout.V0Rollout.Scheduled != nil { r.Scheduled = &ScheduledRollout{} - if d.RolloutV0.Scheduled.Steps != nil { + scheduledRollout := *d.Rollout.V0Rollout.Scheduled + if scheduledRollout.Steps != nil { r.Scheduled.Steps = []ScheduledStep{} - for _, step := range d.RolloutV0.Scheduled.Steps { + for _, step := range scheduledRollout.Steps { f := FlagData{ Rule: step.Rule, Percentage: step.Percentage, @@ -30,16 +31,16 @@ func ConvertDtoToV1(d dto.DTO) FlagData { TrackEvents: step.TrackEvents, Disable: step.Disable, } - if step.RolloutV0 != nil && step.RolloutV0.Progressive != nil { + if step.Rollout != nil && step.Rollout.Progressive != nil { f.Rollout = &Rollout{ Progressive: &Progressive{ ReleaseRamp: ProgressiveReleaseRamp{ - Start: step.RolloutV0.Progressive.ReleaseRamp.Start, - End: step.RolloutV0.Progressive.ReleaseRamp.End, + Start: step.Rollout.Progressive.ReleaseRamp.Start, + End: step.Rollout.Progressive.ReleaseRamp.End, }, Percentage: ProgressivePercentage{ - Initial: step.RolloutV0.Progressive.Percentage.Initial, - End: step.RolloutV0.Progressive.Percentage.End, + Initial: step.Rollout.Progressive.Percentage.Initial, + End: step.Rollout.Progressive.Percentage.End, }, }, } @@ -54,13 +55,13 @@ func ConvertDtoToV1(d dto.DTO) FlagData { } } - if d.RolloutV0.Experimentation != nil { + if d.Rollout.Experimentation != nil { r.Experimentation = &Experimentation{} - if d.RolloutV0.Experimentation.Start != nil { - r.Experimentation.Start = d.RolloutV0.Experimentation.Start + if d.Rollout.Experimentation.Start != nil { + r.Experimentation.Start = d.Rollout.Experimentation.Start } - if d.RolloutV0.Experimentation.End != nil { - r.Experimentation.End = d.RolloutV0.Experimentation.End + if d.Rollout.Experimentation.End != nil { + r.Experimentation.End = d.Rollout.Experimentation.End } } } From 6b1319b31d322cc25c9ab5799c703dfe46534f3f Mon Sep 17 00:00:00 2001 From: Thomas Poignant Date: Mon, 8 Aug 2022 23:20:44 +0200 Subject: [PATCH 27/50] wrong file Signed-off-by: Thomas Poignant --- examples/retriever_file/main.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/examples/retriever_file/main.go b/examples/retriever_file/main.go index 06aec1f8bf2..dda6d3c6125 100644 --- a/examples/retriever_file/main.go +++ b/examples/retriever_file/main.go @@ -21,7 +21,7 @@ func main() { Logger: log.New(os.Stdout, "", 0), Context: context.Background(), Retriever: &fileretriever.Retriever{ - Path: "examples/retrfile/flags.yaml", + Path: "examples/retriever_file/flags.yaml", }, DataExporter: ffclient.DataExporter{ FlushInterval: 1 * time.Second, From 66c2fd6dff39d7b9f4ec11bfd6831fdb0d29536f Mon Sep 17 00:00:00 2001 From: Thomas Poignant Date: Mon, 8 Aug 2022 23:23:41 +0200 Subject: [PATCH 28/50] Rename cli Signed-off-by: Thomas Poignant --- cmd/{flagconverter => migrationcli}/converter.go | 0 cmd/{flagconverter => migrationcli}/main.go | 0 2 files changed, 0 insertions(+), 0 deletions(-) rename cmd/{flagconverter => migrationcli}/converter.go (100%) rename cmd/{flagconverter => migrationcli}/main.go (100%) diff --git a/cmd/flagconverter/converter.go b/cmd/migrationcli/converter.go similarity index 100% rename from cmd/flagconverter/converter.go rename to cmd/migrationcli/converter.go diff --git a/cmd/flagconverter/main.go b/cmd/migrationcli/main.go similarity index 100% rename from cmd/flagconverter/main.go rename to cmd/migrationcli/main.go From 4f36f995df9abe77277915293c1cab010a25409d Mon Sep 17 00:00:00 2001 From: Thomas Poignant Date: Mon, 8 Aug 2022 23:34:33 +0200 Subject: [PATCH 29/50] add doc Signed-off-by: Thomas Poignant --- internal/dto/convert_v1.go | 1 + internal/dto/dto_rollout.go | 49 +++++++++++++++++++++++++++ internal/dto/rollout_progressive.go | 14 -------- internal/dto/rollout_v0.go | 51 ----------------------------- 4 files changed, 50 insertions(+), 65 deletions(-) delete mode 100644 internal/dto/rollout_progressive.go delete mode 100644 internal/dto/rollout_v0.go diff --git a/internal/dto/convert_v1.go b/internal/dto/convert_v1.go index 6a6ea5e0494..6d6bfd8cb96 100644 --- a/internal/dto/convert_v1.go +++ b/internal/dto/convert_v1.go @@ -2,6 +2,7 @@ package dto import "github.com/thomaspoignant/go-feature-flag/internal/flag" +// ConvertV1DtoToInternalFlag is converting a DTO to a flag.InternalFlag func ConvertV1DtoToInternalFlag(dto DTO) flag.InternalFlag { var rollout *flag.Rollout if dto.Rollout != nil { diff --git a/internal/dto/dto_rollout.go b/internal/dto/dto_rollout.go index 8e36e85ca58..2931e209893 100644 --- a/internal/dto/dto_rollout.go +++ b/internal/dto/dto_rollout.go @@ -41,10 +41,16 @@ type CommonRollout struct { } type V1Rollout struct { + // Scheduled is your struct to configure an update on some fields of your flag over time. + // You can add several steps that updates the flag, this is typically used if you want to gradually add more user + // in your flag. Scheduled *[]flag.ScheduledStep `json:"scheduled,omitempty" yaml:"scheduled,omitempty" toml:"scheduled,omitempty"` // nolint: lll } type V0Rollout struct { + // Scheduled is your struct to configure an update on some fields of your flag over time. + // You can add several steps that updates the flag, this is typically used if you want to gradually add more user + // in your flag. Scheduled *ScheduledRolloutV0 `json:"scheduled,omitempty" yaml:"scheduled,omitempty" toml:"scheduled,omitempty"` // nolint: lll } @@ -71,3 +77,46 @@ func (p *Rollout) UnmarshalJSON(data []byte) error { return nil } + +type ScheduledRolloutV0 struct { + // Steps is the list of updates to do in a specific date. + Steps []ScheduledStepV0 `json:"steps,omitempty" yaml:"steps,omitempty" toml:"steps,omitempty"` +} + +type ScheduledStepV0 struct { + DTO `yaml:",inline"` + Date *time.Time `json:"date,omitempty" yaml:"date,omitempty" toml:"date,omitempty"` +} + +// ProgressiveV0 is the configuration struct to define a progressive rollout. +type ProgressiveV0 struct { + // Percentage is where you can configure at what percentage your progressive rollout start + // and at what percentage it ends. + // This field is optional + Percentage ProgressivePercentageV0 `json:"percentage,omitempty" yaml:"percentage,omitempty" toml:"percentage,omitempty"` // nolint: lll + + // ReleaseRamp is the defining when the progressive rollout starts and ends. + // This field is mandatory if you want to use a progressive rollout. + // If any field missing we ignore the progressive rollout. + ReleaseRamp ProgressiveReleaseRampV0 `json:"releaseRamp,omitempty" yaml:"releaseRamp,omitempty" toml:"releaseRamp,omitempty"` // nolint: lll +} + +type ProgressivePercentageV0 struct { + // Initial is the initial percentage before the rollout start date. + // This field is optional + // Default: 0.0 + Initial float64 `json:"initial,omitempty" yaml:"initial,omitempty" toml:"initial,omitempty"` + + // End is the target percentage we want to reach at the end of the rollout phase. + // This field is optional + // Default: 100.0 + End float64 `json:"end,omitempty" yaml:"end,omitempty" toml:"end,omitempty"` +} + +type ProgressiveReleaseRampV0 struct { + // Start is the starting time of the ramp + Start *time.Time `json:"start,omitempty" yaml:"start,omitempty" toml:"start,omitempty"` + + // End is the ending time of the ramp + End *time.Time `json:"end,omitempty" yaml:"end,omitempty" toml:"end,omitempty"` +} diff --git a/internal/dto/rollout_progressive.go b/internal/dto/rollout_progressive.go deleted file mode 100644 index 709f101c51c..00000000000 --- a/internal/dto/rollout_progressive.go +++ /dev/null @@ -1,14 +0,0 @@ -package dto - -// ProgressiveV0 is the configuration struct to define a progressive rollout. -type ProgressiveV0 struct { - // Percentage is where you can configure at what percentage your progressive rollout start - // and at what percentage it ends. - // This field is optional - Percentage ProgressivePercentageV0 `json:"percentage,omitempty" yaml:"percentage,omitempty" toml:"percentage,omitempty"` // nolint: lll - - // ReleaseRamp is the defining when the progressive rollout starts and ends. - // This field is mandatory if you want to use a progressive rollout. - // If any field missing we ignore the progressive rollout. - ReleaseRamp ProgressiveReleaseRampV0 `json:"releaseRamp,omitempty" yaml:"releaseRamp,omitempty" toml:"releaseRamp,omitempty"` // nolint: lll -} diff --git a/internal/dto/rollout_v0.go b/internal/dto/rollout_v0.go deleted file mode 100644 index 8fd2ee2ba8c..00000000000 --- a/internal/dto/rollout_v0.go +++ /dev/null @@ -1,51 +0,0 @@ -package dto - -import "time" - -type RolloutV0 struct { - // Experimentation is your struct to configure an experimentation, it will allow you to configure a start date and - // an end date for your flag. - // When the experimentation is not running, the flag will serve the default value. - Experimentation *ExperimentationDto `json:"experimentation,omitempty" yaml:"experimentation,omitempty" toml:"experimentation,omitempty"` // nolint: lll - - // Progressive is your struct to configure a progressive rollout deployment of your flag. - // It will allow you to ramp up the percentage of your flag over time. - // You can decide at which percentage you start and at what percentage you ends in your release ramp. - // Before the start date we will serve the initial percentage and, after we will serve the end percentage. - Progressive *ProgressiveV0 `json:"progressive,omitempty" yaml:"progressive,omitempty" toml:"progressive,omitempty"` // nolint: lll - - // Scheduled is your struct to configure an update on some fields of your flag over time. - // You can add several steps that updates the flag, this is typically used if you want to gradually add more user - // in your flag. - Scheduled *ScheduledRolloutV0 `json:"scheduled,omitempty" yaml:"scheduled,omitempty" toml:"scheduled,omitempty"` // nolint: lll -} - -type ProgressivePercentageV0 struct { - // Initial is the initial percentage before the rollout start date. - // This field is optional - // Default: 0.0 - Initial float64 `json:"initial,omitempty" yaml:"initial,omitempty" toml:"initial,omitempty"` - - // End is the target percentage we want to reach at the end of the rollout phase. - // This field is optional - // Default: 100.0 - End float64 `json:"end,omitempty" yaml:"end,omitempty" toml:"end,omitempty"` -} - -type ProgressiveReleaseRampV0 struct { - // Start is the starting time of the ramp - Start *time.Time `json:"start,omitempty" yaml:"start,omitempty" toml:"start,omitempty"` - - // End is the ending time of the ramp - End *time.Time `json:"end,omitempty" yaml:"end,omitempty" toml:"end,omitempty"` -} - -type ScheduledRolloutV0 struct { - // Steps is the list of updates to do in a specific date. - Steps []ScheduledStepV0 `json:"steps,omitempty" yaml:"steps,omitempty" toml:"steps,omitempty"` -} - -type ScheduledStepV0 struct { - DTO `yaml:",inline"` - Date *time.Time `json:"date,omitempty" yaml:"date,omitempty" toml:"date,omitempty"` -} From e949a887a278c330b2f9caacbd1fa4335291ad78 Mon Sep 17 00:00:00 2001 From: Thomas Poignant Date: Mon, 8 Aug 2022 23:53:50 +0200 Subject: [PATCH 30/50] Remove usage of ioutil Signed-off-by: Thomas Poignant --- cmd/migrationcli/converter.go | 6 ++-- exporter/fileexporter/exporter_test.go | 9 +++-- exporter/gcstorageexporter/exporter.go | 5 ++- exporter/logsexporter/exporter_test.go | 6 ++-- exporter/s3exporter/exporter.go | 5 ++- exporter/s3exporter/exporter_test.go | 3 +- exporter/webhookexporter/exporter.go | 6 ++-- exporter/webhookexporter/exporter_test.go | 3 +- feature_flag_bench_test.go | 8 ++--- feature_flag_test.go | 15 ++++----- internal/dataexporter/data_exporter_test.go | 5 ++- notifier/logsnotifier/notifier_test.go | 5 ++- notifier/slacknotifier/notifier.go | 4 +-- notifier/slacknotifier/notifier_test.go | 3 +- notifier/webhooknotifier/notifier.go | 4 +-- notifier/webhooknotifier/notifier_test.go | 4 +-- retriever/fileretriever/retriever.go | 4 +-- retriever/gcstorageretriever/retriever.go | 3 +- .../gcstorageretriever/retriever_test.go | 6 ++-- retriever/httpretriever/retriever.go | 4 +-- retriever/s3retriever/retriever.go | 6 ++-- retriever/s3retriever/retriever_test.go | 4 +-- testutils/mock/httpmock.go | 6 ++-- testutils/mock_gc_storage_reader.go | 4 +-- testutils/mock_httpclient.go | 6 ++-- testutils/mock_s3manager.go | 4 +-- variation_test.go | 33 +++++++++---------- 27 files changed, 80 insertions(+), 91 deletions(-) diff --git a/cmd/migrationcli/converter.go b/cmd/migrationcli/converter.go index c10cc260471..847d9d7b614 100644 --- a/cmd/migrationcli/converter.go +++ b/cmd/migrationcli/converter.go @@ -3,7 +3,7 @@ package main import ( "encoding/json" "fmt" - "io/ioutil" + "os" "strings" "github.com/pelletier/go-toml" @@ -22,7 +22,7 @@ type FlagConverter struct { func (f *FlagConverter) Migrate() error { // Read content of the file - content, err := ioutil.ReadFile(f.InputFile) + content, err := os.ReadFile(f.InputFile) if err != nil { return fmt.Errorf("file %v is impossible to find", f.InputFile) } @@ -92,5 +92,5 @@ func (f *FlagConverter) output(fileContent []byte) error { return nil } - return ioutil.WriteFile(f.OutputFile, fileContent, 0o600) + return os.WriteFile(f.OutputFile, fileContent, os.ModePerm) } diff --git a/exporter/fileexporter/exporter_test.go b/exporter/fileexporter/exporter_test.go index b6a85bee64e..8f37e281e0b 100644 --- a/exporter/fileexporter/exporter_test.go +++ b/exporter/fileexporter/exporter_test.go @@ -2,7 +2,6 @@ package fileexporter_test import ( "context" - "io/ioutil" "log" "os" "testing" @@ -215,7 +214,7 @@ func TestFile_Export(t *testing.T) { t.Run(tt.name, func(t *testing.T) { outputDir := tt.fields.OutputDir if tt.fields.OutputDir == "" { - outputDir, _ = ioutil.TempDir("", "fileExporter") + outputDir, _ = os.MkdirTemp("", "fileExporter") defer os.Remove(outputDir) } @@ -231,12 +230,12 @@ func TestFile_Export(t *testing.T) { return } - files, _ := ioutil.ReadDir(outputDir) + files, _ := os.ReadDir(outputDir) assert.Equal(t, 1, len(files), "Directory %s should have only one file", outputDir) assert.Regexp(t, tt.expected.fileNameRegex, files[0].Name(), "Invalid file name") - expectedContent, _ := ioutil.ReadFile(tt.expected.content) - gotContent, _ := ioutil.ReadFile(outputDir + "/" + files[0].Name()) + expectedContent, _ := os.ReadFile(tt.expected.content) + gotContent, _ := os.ReadFile(outputDir + "/" + files[0].Name()) assert.Equal(t, string(expectedContent), string(gotContent), "Wrong content in the output file") }) } diff --git a/exporter/gcstorageexporter/exporter.go b/exporter/gcstorageexporter/exporter.go index 7797a11e259..2e9f5db3f19 100644 --- a/exporter/gcstorageexporter/exporter.go +++ b/exporter/gcstorageexporter/exporter.go @@ -4,7 +4,6 @@ import ( "context" "fmt" "io" - "io/ioutil" "log" "os" @@ -64,7 +63,7 @@ func (f *Exporter) Export(ctx context.Context, logger *log.Logger, featureEvents } // Create a temp directory to store the file we will produce - outputDir, err := ioutil.TempDir("", "go_feature_flag_GoogleCloudStorage_export") + outputDir, err := os.MkdirTemp("", "go_feature_flag_GoogleCloudStorage_export") if err != nil { return err } @@ -84,7 +83,7 @@ func (f *Exporter) Export(ctx context.Context, logger *log.Logger, featureEvents } // Upload all the files in the folder to google storage - files, err := ioutil.ReadDir(outputDir) + files, err := os.ReadDir(outputDir) if err != nil { return err } diff --git a/exporter/logsexporter/exporter_test.go b/exporter/logsexporter/exporter_test.go index 5c8f48f963a..c2c4d9c85bf 100644 --- a/exporter/logsexporter/exporter_test.go +++ b/exporter/logsexporter/exporter_test.go @@ -2,8 +2,8 @@ package logsexporter_test import ( "context" - "io/ioutil" "log" + "os" "testing" "github.com/thomaspoignant/go-feature-flag/exporter/logsexporter" @@ -86,7 +86,7 @@ func TestLog_Export(t *testing.T) { LogFormat: tt.fields.LogFormat, } - logFile, _ := ioutil.TempFile("", "") + logFile, _ := os.CreateTemp("", "") logger := log.New(logFile, "", 0) err := f.Export(context.Background(), logger, tt.args.featureEvents) @@ -98,7 +98,7 @@ func TestLog_Export(t *testing.T) { assert.NoError(t, err, "Exporter exporter should not throw errors") - logContent, _ := ioutil.ReadFile(logFile.Name()) + logContent, _ := os.ReadFile(logFile.Name()) assert.Regexp(t, tt.expectedLog, string(logContent)) }) } diff --git a/exporter/s3exporter/exporter.go b/exporter/s3exporter/exporter.go index b9f51c3f350..a4bdd1b48e6 100644 --- a/exporter/s3exporter/exporter.go +++ b/exporter/s3exporter/exporter.go @@ -2,7 +2,6 @@ package s3exporter import ( "context" - "io/ioutil" "log" "os" "sync" @@ -69,7 +68,7 @@ func (f *Exporter) Export(ctx context.Context, logger *log.Logger, featureEvents } // Create a temp directory to store the file we will produce - outputDir, err := ioutil.TempDir("", "go_feature_flag_s3_export") + outputDir, err := os.MkdirTemp("", "go_feature_flag_s3_export") if err != nil { return err } @@ -89,7 +88,7 @@ func (f *Exporter) Export(ctx context.Context, logger *log.Logger, featureEvents } // Upload all the files in the folder to Exporter - files, err := ioutil.ReadDir(outputDir) + files, err := os.ReadDir(outputDir) if err != nil { return err } diff --git a/exporter/s3exporter/exporter_test.go b/exporter/s3exporter/exporter_test.go index 34d342968f2..f3985c270e7 100644 --- a/exporter/s3exporter/exporter_test.go +++ b/exporter/s3exporter/exporter_test.go @@ -2,7 +2,6 @@ package s3exporter import ( "context" - "io/ioutil" "log" "os" "testing" @@ -187,7 +186,7 @@ func TestS3_Export(t *testing.T) { assert.NoError(t, err, "Export should not error") assert.Equal(t, 1, len(s3ManagerMock.S3ManagerMockFileSystem), "we should have 1 file in our mock") - expectedContent, _ := ioutil.ReadFile(tt.expectedFile) + expectedContent, _ := os.ReadFile(tt.expectedFile) for k, v := range s3ManagerMock.S3ManagerMockFileSystem { assert.Equal(t, string(expectedContent), v, "invalid file content") assert.Regexp(t, tt.expectedName, k, "invalid file name") diff --git a/exporter/webhookexporter/exporter.go b/exporter/webhookexporter/exporter.go index 7eb2952d0cc..d7e1563b2ef 100644 --- a/exporter/webhookexporter/exporter.go +++ b/exporter/webhookexporter/exporter.go @@ -5,7 +5,7 @@ import ( "context" "encoding/json" "fmt" - "io/ioutil" + "io" "log" "net/http" "os" @@ -94,7 +94,7 @@ func (f *Exporter) Export(ctx context.Context, logger *log.Logger, featureEvents } request, err := http.NewRequestWithContext( - ctx, http.MethodPost, f.EndpointURL, ioutil.NopCloser(bytes.NewReader(payload))) + ctx, http.MethodPost, f.EndpointURL, io.NopCloser(bytes.NewReader(payload))) if err != nil { return err } @@ -104,7 +104,7 @@ func (f *Exporter) Export(ctx context.Context, logger *log.Logger, featureEvents if err != nil { return err } - defer response.Body.Close() + defer func() { _ = response.Body.Close() }() if response.StatusCode > 399 { return fmt.Errorf( "error while calling the webhook, HTTP Code %d received, response: %v", response.StatusCode, response.Body) diff --git a/exporter/webhookexporter/exporter_test.go b/exporter/webhookexporter/exporter_test.go index 42b80117540..0c1e6863b0a 100644 --- a/exporter/webhookexporter/exporter_test.go +++ b/exporter/webhookexporter/exporter_test.go @@ -3,7 +3,6 @@ package webhookexporter import ( "context" "fmt" - "io/ioutil" "log" "os" "testing" @@ -166,7 +165,7 @@ func TestWebhook_Export(t *testing.T) { assert.NoError(t, err) if tt.expected.bodyFilePath != "" { - c, err := ioutil.ReadFile(tt.expected.bodyFilePath) + c, err := os.ReadFile(tt.expected.bodyFilePath) fmt.Println(err) assert.JSONEq(t, string(c), tt.fields.httpClient.Body) } diff --git a/feature_flag_bench_test.go b/feature_flag_bench_test.go index a23632901c4..a319a7e1fbe 100644 --- a/feature_flag_bench_test.go +++ b/feature_flag_bench_test.go @@ -3,7 +3,7 @@ package ffclient_test import ( "bytes" "fmt" - "io/ioutil" + "os" "testing" "text/template" "time" @@ -19,7 +19,7 @@ var client *ffclient.GoFeatureFlag // init is creating a flag file for this test with the expected date. func init() { - content, _ := ioutil.ReadFile("testdata/benchmark/flag-config.yaml") + content, _ := os.ReadFile("testdata/benchmark/flag-config.yaml") t, _ := template.New("example-flag-config").Parse(string(content)) var buf bytes.Buffer @@ -33,8 +33,8 @@ func init() { DateAfter: time.Now().Add(3 * time.Second).Format(time.RFC3339), }) - flagFile, _ := ioutil.TempFile("", "") - _ = ioutil.WriteFile(flagFile.Name(), buf.Bytes(), 0o600) + flagFile, _ := os.CreateTemp("", "") + _ = os.WriteFile(flagFile.Name(), buf.Bytes(), os.ModePerm) client, _ = ffclient.New(ffclient.Config{ PollingInterval: 1 * time.Second, diff --git a/feature_flag_test.go b/feature_flag_test.go index 23dbe5b11ac..9c968dc1377 100644 --- a/feature_flag_test.go +++ b/feature_flag_test.go @@ -1,7 +1,6 @@ package ffclient_test import ( - "io/ioutil" "log" "os" "testing" @@ -174,8 +173,8 @@ func TestUpdateFlag(t *testing.T) { false: false default: false` - flagFile, _ := ioutil.TempFile("", "") - _ = ioutil.WriteFile(flagFile.Name(), []byte(initialFileContent), 0o600) + flagFile, _ := os.CreateTemp("", "") + _ = os.WriteFile(flagFile.Name(), []byte(initialFileContent), os.ModePerm) gffClient1, _ := ffclient.New(ffclient.Config{ PollingInterval: 1 * time.Second, @@ -194,7 +193,7 @@ func TestUpdateFlag(t *testing.T) { false: false default: false` - _ = ioutil.WriteFile(flagFile.Name(), []byte(updatedFileContent), 0o600) + _ = os.WriteFile(flagFile.Name(), []byte(updatedFileContent), os.ModePerm) flagValue, _ = gffClient1.BoolVariation("test-flag", ffuser.NewUser("random-key"), false) assert.True(t, flagValue) @@ -213,8 +212,8 @@ func TestImpossibleToLoadfile(t *testing.T) { false: false default: false` - flagFile, _ := ioutil.TempFile("", "impossible") - _ = ioutil.WriteFile(flagFile.Name(), []byte(initialFileContent), 0o600) + flagFile, _ := os.CreateTemp("", "impossible") + _ = os.WriteFile(flagFile.Name(), []byte(initialFileContent), os.ModePerm) gffClient1, _ := ffclient.New(ffclient.Config{ PollingInterval: 1 * time.Second, @@ -245,7 +244,7 @@ func TestFlagFileUnreachable(t *testing.T) { false: "false" default: "false"` - tempDir, _ := ioutil.TempDir("", "") + tempDir, _ := os.MkdirTemp("", "") defer os.Remove(tempDir) flagFilePath := tempDir + "_FlagFileUnreachable.yaml" @@ -262,7 +261,7 @@ func TestFlagFileUnreachable(t *testing.T) { flagValue, _ := gff.StringVariation("test-flag", ffuser.NewUser("random-key"), "SDKdefault") assert.Equal(t, "SDKdefault", flagValue, "should use the SDK default value") - _ = ioutil.WriteFile(flagFilePath, []byte(initialFileContent), 0o600) + _ = os.WriteFile(flagFilePath, []byte(initialFileContent), os.ModePerm) time.Sleep(2 * time.Second) flagValue, _ = gff.StringVariation("test-flag", ffuser.NewUser("random-key"), "SDKdefault") diff --git a/internal/dataexporter/data_exporter_test.go b/internal/dataexporter/data_exporter_test.go index 99c77e92b26..653d494dbd7 100644 --- a/internal/dataexporter/data_exporter_test.go +++ b/internal/dataexporter/data_exporter_test.go @@ -3,7 +3,6 @@ package dataexporter_test import ( "context" "errors" - "io/ioutil" "log" "os" "testing" @@ -78,7 +77,7 @@ func TestDataExporterScheduler_defaultFlush(t *testing.T) { func TestDataExporterScheduler_exporterReturnError(t *testing.T) { mockExporter := mock.Exporter{Err: errors.New("random err"), ExpectedNumberErr: 1, Bulk: true} - file, _ := ioutil.TempFile("", "log") + file, _ := os.CreateTemp("", "log") defer file.Close() defer os.Remove(file.Name()) logger := log.New(file, "", 0) @@ -99,7 +98,7 @@ func TestDataExporterScheduler_exporterReturnError(t *testing.T) { assert.Equal(t, inputEvents[:201], mockExporter.GetExportedEvents()) // read log - logs, _ := ioutil.ReadFile(file.Name()) + logs, _ := os.ReadFile(file.Name()) assert.Regexp(t, "\\["+testutils.RFC3339Regex+"\\] error while exporting data: random err\\n", string(logs)) } diff --git a/notifier/logsnotifier/notifier_test.go b/notifier/logsnotifier/notifier_test.go index ce3ca1d6e64..2f728979f44 100644 --- a/notifier/logsnotifier/notifier_test.go +++ b/notifier/logsnotifier/notifier_test.go @@ -1,7 +1,6 @@ package logsnotifier import ( - "io/ioutil" "log" "os" "sync" @@ -255,7 +254,7 @@ func TestLogNotifier_Notify(t *testing.T) { } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { - logOutput, _ := ioutil.TempFile("", "") + logOutput, _ := os.CreateTemp("", "") defer os.Remove(logOutput.Name()) c := &Notifier{ @@ -263,7 +262,7 @@ func TestLogNotifier_Notify(t *testing.T) { } tt.args.wg.Add(1) _ = c.Notify(tt.args.diff, tt.args.wg) - log, _ := ioutil.ReadFile(logOutput.Name()) + log, _ := os.ReadFile(logOutput.Name()) assert.Regexp(t, tt.expected, string(log)) }) } diff --git a/notifier/slacknotifier/notifier.go b/notifier/slacknotifier/notifier.go index 448ca46d170..4c83fb4d628 100644 --- a/notifier/slacknotifier/notifier.go +++ b/notifier/slacknotifier/notifier.go @@ -4,7 +4,7 @@ import ( "bytes" "encoding/json" "fmt" - "io/ioutil" + "io" "net/http" "net/url" "os" @@ -63,7 +63,7 @@ func (c *Notifier) Notify(diff notifier.DiffCache, wg *sync.WaitGroup) error { request := http.Request{ Method: http.MethodPost, URL: slackURL, - Body: ioutil.NopCloser(bytes.NewReader(payload)), + Body: io.NopCloser(bytes.NewReader(payload)), Header: map[string][]string{"Content-type": {"application/json"}}, } response, err := c.httpClient.Do(&request) diff --git a/notifier/slacknotifier/notifier_test.go b/notifier/slacknotifier/notifier_test.go index 4b71eaf148a..dbed325a26c 100644 --- a/notifier/slacknotifier/notifier_test.go +++ b/notifier/slacknotifier/notifier_test.go @@ -1,7 +1,6 @@ package slacknotifier import ( - "io/ioutil" "net/http" "os" "strings" @@ -211,7 +210,7 @@ func TestSlackNotifier_Notify(t *testing.T) { } else { assert.NoError(t, err) hostname, _ := os.Hostname() - content, _ := ioutil.ReadFile(tt.expected.bodyPath) + content, _ := os.ReadFile(tt.expected.bodyPath) expectedContent := strings.ReplaceAll(string(content), "{{hostname}}", hostname) assert.JSONEq(t, expectedContent, mockHTTPClient.Body) assert.Equal(t, tt.expected.signature, mockHTTPClient.Signature) diff --git a/notifier/webhooknotifier/notifier.go b/notifier/webhooknotifier/notifier.go index 98151f3b92e..83105ebf1dd 100644 --- a/notifier/webhooknotifier/notifier.go +++ b/notifier/webhooknotifier/notifier.go @@ -4,7 +4,7 @@ import ( "bytes" "encoding/json" "fmt" - "io/ioutil" + "io" "net/http" "net/url" "os" @@ -133,7 +133,7 @@ func (c *Notifier) Notify(diff notifier.DiffCache, wg *sync.WaitGroup) error { Method: "POST", URL: endpointURL, Header: headers, - Body: ioutil.NopCloser(bytes.NewReader(payload)), + Body: io.NopCloser(bytes.NewReader(payload)), } response, err := c.httpClient.Do(&request) // Log if something went wrong while calling the webhook. diff --git a/notifier/webhooknotifier/notifier_test.go b/notifier/webhooknotifier/notifier_test.go index 378a23e019e..5403a964ab9 100644 --- a/notifier/webhooknotifier/notifier_test.go +++ b/notifier/webhooknotifier/notifier_test.go @@ -3,8 +3,8 @@ package webhooknotifier import ( "encoding/json" "fmt" - "io/ioutil" "net/http" + "os" "sync" "testing" @@ -230,7 +230,7 @@ func Test_webhookNotifier_Notify(t *testing.T) { assert.ErrorContains(t, err, tt.expected.errorMsg) } else { assert.NoError(t, err) - content, _ := ioutil.ReadFile(tt.expected.bodyPath) + content, _ := os.ReadFile(tt.expected.bodyPath) fmt.Println(mockHTTPClient.Body) assert.JSONEq(t, string(content), mockHTTPClient.Body) assert.Equal(t, tt.expected.signature, mockHTTPClient.Signature) diff --git a/retriever/fileretriever/retriever.go b/retriever/fileretriever/retriever.go index c3c813a1eef..ef5ca4cc8cd 100644 --- a/retriever/fileretriever/retriever.go +++ b/retriever/fileretriever/retriever.go @@ -2,7 +2,7 @@ package fileretriever import ( "context" - "io/ioutil" + "os" ) // Retriever is a configuration struct for a local flat file. @@ -12,7 +12,7 @@ type Retriever struct { // Retrieve is reading the file and return the content func (r *Retriever) Retrieve(ctx context.Context) ([]byte, error) { - content, err := ioutil.ReadFile(r.Path) + content, err := os.ReadFile(r.Path) if err != nil { return nil, err } diff --git a/retriever/gcstorageretriever/retriever.go b/retriever/gcstorageretriever/retriever.go index 3ac8141626f..2c01cc57f10 100644 --- a/retriever/gcstorageretriever/retriever.go +++ b/retriever/gcstorageretriever/retriever.go @@ -6,7 +6,6 @@ import ( "crypto/md5" //nolint: gosec "fmt" "io" - "io/ioutil" "cloud.google.com/go/storage" @@ -76,7 +75,7 @@ func (retriever *Retriever) Retrieve(ctx context.Context) (content []byte, err e defer retriever.rC.Close() // Read all contents from the Reader. - content, err = ioutil.ReadAll(retriever.rC) + content, err = io.ReadAll(retriever.rC) if err != nil { return nil, fmt.Errorf( "unable to read from GCP Object %s in Bucket %s, error: %s", retriever.Bucket, retriever.Object, err, diff --git a/retriever/gcstorageretriever/retriever_test.go b/retriever/gcstorageretriever/retriever_test.go index fcd0d26ad1e..6c700378e32 100644 --- a/retriever/gcstorageretriever/retriever_test.go +++ b/retriever/gcstorageretriever/retriever_test.go @@ -4,7 +4,7 @@ import ( "context" "crypto/md5" //nolint: gosec "io" - "io/ioutil" + "os" "testing" "cloud.google.com/go/storage" @@ -114,7 +114,7 @@ func TestGCStorageRetriever_Retrieve(t *testing.T) { } // Read default file. - want, err := ioutil.ReadFile("./testdata/flag-config.yaml") + want, err := os.ReadFile("./testdata/flag-config.yaml") assert.NoError(t, err) r.cache = want @@ -132,7 +132,7 @@ func TestGCStorageRetriever_Retrieve(t *testing.T) { // If expect data not to be in cache, mock the // remote hash to a different one that the local hash. - want, err = ioutil.ReadFile("./testdata/flag-config-updated.yaml") + want, err = os.ReadFile("./testdata/flag-config-updated.yaml") assert.NoError(t, err) md5Hash = md5.Sum(want) //nolint: gosec diff --git a/retriever/httpretriever/retriever.go b/retriever/httpretriever/retriever.go index b471ea447d1..5ef40951ee9 100644 --- a/retriever/httpretriever/retriever.go +++ b/retriever/httpretriever/retriever.go @@ -4,7 +4,7 @@ import ( "context" "errors" "fmt" - "io/ioutil" + "io" "net/http" "strings" "time" @@ -84,7 +84,7 @@ func (r *Retriever) Retrieve(ctx context.Context) ([]byte, error) { } // read content of the URL. - body, err := ioutil.ReadAll(resp.Body) + body, err := io.ReadAll(resp.Body) if err != nil { return nil, err } diff --git a/retriever/s3retriever/retriever.go b/retriever/s3retriever/retriever.go index cdb32a00e02..30bac5d8ee9 100644 --- a/retriever/s3retriever/retriever.go +++ b/retriever/s3retriever/retriever.go @@ -3,7 +3,7 @@ package s3retriever import ( "context" "fmt" - "io/ioutil" + "os" "github.com/aws/aws-sdk-go/aws" "github.com/aws/aws-sdk-go/aws/session" @@ -32,7 +32,7 @@ func (s *Retriever) Retrieve(ctx context.Context) ([]byte, error) { // Download the item from the bucket. // If an error occurs, log it and exit. // Otherwise, notify the user that the download succeeded. - file, err := ioutil.TempFile("", "go_feature_flag") + file, err := os.CreateTemp("", "go_feature_flag") if err != nil { return nil, err } @@ -64,7 +64,7 @@ func (s *Retriever) Retrieve(ctx context.Context) ([]byte, error) { } // Read file content - content, err := ioutil.ReadAll(file) + content, err := os.ReadFile(file.Name()) if err != nil { return nil, err } diff --git a/retriever/s3retriever/retriever_test.go b/retriever/s3retriever/retriever_test.go index 83741670d7f..be7a3d4acd6 100644 --- a/retriever/s3retriever/retriever_test.go +++ b/retriever/s3retriever/retriever_test.go @@ -2,7 +2,7 @@ package s3retriever import ( "context" - "io/ioutil" + "os" "testing" "github.com/aws/aws-sdk-go/aws" @@ -73,7 +73,7 @@ func Test_s3Retriever_Retrieve(t *testing.T) { got, err := s.Retrieve(tt.fields.context) assert.Equal(t, tt.wantErr, err != nil, "Retrieve() error = %v, wantErr %v", err, tt.wantErr) if err == nil { - want, err := ioutil.ReadFile(tt.want) + want, err := os.ReadFile(tt.want) assert.NoError(t, err) assert.Equal(t, string(want), string(got), "Retrieve() got = %v, want %v", string(want), string(got)) } diff --git a/testutils/mock/httpmock.go b/testutils/mock/httpmock.go index 5bbd2275615..b2fc5f02ac1 100644 --- a/testutils/mock/httpmock.go +++ b/testutils/mock/httpmock.go @@ -3,7 +3,7 @@ package mock import ( "bytes" "errors" - "io/ioutil" + "io" "net/http" "strings" ) @@ -17,7 +17,7 @@ func (m *HTTP) Do(req *http.Request) (*http.Response, error) { success := &http.Response{ Status: "OK", StatusCode: http.StatusOK, - Body: ioutil.NopCloser(bytes.NewReader([]byte(`test-flag: + Body: io.NopCloser(bytes.NewReader([]byte(`test-flag: rule: key eq "random-key" percentage: 100 true: true @@ -29,7 +29,7 @@ func (m *HTTP) Do(req *http.Request) (*http.Response, error) { error := &http.Response{ Status: "KO", StatusCode: http.StatusInternalServerError, - Body: ioutil.NopCloser(bytes.NewReader([]byte(""))), + Body: io.NopCloser(bytes.NewReader([]byte(""))), } if strings.HasSuffix(req.URL.String(), "error") { diff --git a/testutils/mock_gc_storage_reader.go b/testutils/mock_gc_storage_reader.go index 89349511c21..e0fa0644300 100644 --- a/testutils/mock_gc_storage_reader.go +++ b/testutils/mock_gc_storage_reader.go @@ -3,7 +3,7 @@ package testutils import ( "fmt" "io" - "io/ioutil" + "os" ) type GCStorageReaderMock struct { @@ -24,7 +24,7 @@ func (r *GCStorageReaderMock) Read(p []byte) (n int, err error) { // Set the mocked data to be read. if r.data == nil { - r.data, err = ioutil.ReadFile(r.FileToRead) + r.data, err = os.ReadFile(r.FileToRead) if err != nil { return 0, err } diff --git a/testutils/mock_httpclient.go b/testutils/mock_httpclient.go index fe3eca86f44..2b85e01704c 100644 --- a/testutils/mock_httpclient.go +++ b/testutils/mock_httpclient.go @@ -3,7 +3,7 @@ package testutils import ( "bytes" "errors" - "io/ioutil" + "io" "net/http" ) @@ -19,11 +19,11 @@ func (h *HTTPClientMock) Do(req *http.Request) (*http.Response, error) { return nil, errors.New("random error") } - b, _ := ioutil.ReadAll(req.Body) + b, _ := io.ReadAll(req.Body) h.Body = string(b) h.Signature = req.Header.Get("X-Hub-Signature-256") resp := &http.Response{ - Body: ioutil.NopCloser(bytes.NewReader([]byte(""))), + Body: io.NopCloser(bytes.NewReader([]byte(""))), } resp.StatusCode = h.StatusCode return resp, nil diff --git a/testutils/mock_s3manager.go b/testutils/mock_s3manager.go index 038c198fe5e..b64d5e381e9 100644 --- a/testutils/mock_s3manager.go +++ b/testutils/mock_s3manager.go @@ -3,7 +3,7 @@ package testutils import ( "errors" "io" - "io/ioutil" + "os" "strings" "github.com/aws/aws-sdk-go/aws" @@ -20,7 +20,7 @@ func (s *S3ManagerMock) Download(at io.WriterAt, input *s3.GetObjectInput, f ...func(*s3manager.Downloader), ) (int64, error) { if *input.Key == "valid" { - res, _ := ioutil.ReadFile(s.TestDataLocation + "/flag-config.yaml") + res, _ := os.ReadFile(s.TestDataLocation + "/flag-config.yaml") _, _ = at.WriteAt(res, 0) return 1, nil } else if *input.Key == "no-file" { diff --git a/variation_test.go b/variation_test.go index 31ec229d051..a7de97ce050 100644 --- a/variation_test.go +++ b/variation_test.go @@ -4,7 +4,6 @@ import ( "context" "encoding/json" "errors" - "io/ioutil" "log" "os" "testing" @@ -287,7 +286,7 @@ func TestBoolVariation(t *testing.T) { for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { // init logger - file, _ := ioutil.TempFile("", "log") + file, _ := os.CreateTemp("", "log") logger := log.New(file, "", 0) ff = &GoFeatureFlag{ @@ -308,7 +307,7 @@ func TestBoolVariation(t *testing.T) { got, err := BoolVariation(tt.args.flagKey, tt.args.user, tt.args.defaultValue) if tt.expectedLog != "" { - content, _ := ioutil.ReadFile(file.Name()) + content, _ := os.ReadFile(file.Name()) assert.Regexp(t, tt.expectedLog, string(content)) } @@ -560,7 +559,7 @@ func TestFloat64Variation(t *testing.T) { for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { // init logger - file, _ := ioutil.TempFile("", "log") + file, _ := os.CreateTemp("", "log") logger := log.New(file, "", 0) ff = &GoFeatureFlag{ @@ -581,7 +580,7 @@ func TestFloat64Variation(t *testing.T) { got, err := Float64Variation(tt.args.flagKey, tt.args.user, tt.args.defaultValue) if tt.expectedLog != "" { - content, _ := ioutil.ReadFile(file.Name()) + content, _ := os.ReadFile(file.Name()) assert.Regexp(t, tt.expectedLog, string(content)) } if tt.wantErr { @@ -818,7 +817,7 @@ func TestJSONArrayVariation(t *testing.T) { for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { // init logger - file, _ := ioutil.TempFile("", "log") + file, _ := os.CreateTemp("", "log") logger := log.New(file, "", 0) ff = &GoFeatureFlag{ @@ -841,7 +840,7 @@ func TestJSONArrayVariation(t *testing.T) { } assert.Equal(t, tt.want, got, "JSONArrayVariation() got = %v, want %v", got, tt.want) if tt.expectedLog != "" { - content, _ := ioutil.ReadFile(file.Name()) + content, _ := os.ReadFile(file.Name()) assert.Regexp(t, tt.expectedLog, string(content)) } // clean logger @@ -1053,7 +1052,7 @@ func TestJSONVariation(t *testing.T) { for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { // init logger - file, _ := ioutil.TempFile("", "log") + file, _ := os.CreateTemp("", "log") logger := log.New(file, "", 0) ff = &GoFeatureFlag{ @@ -1074,7 +1073,7 @@ func TestJSONVariation(t *testing.T) { got, err := JSONVariation(tt.args.flagKey, tt.args.user, tt.args.defaultValue) if tt.expectedLog != "" { - content, _ := ioutil.ReadFile(file.Name()) + content, _ := os.ReadFile(file.Name()) assert.Regexp(t, tt.expectedLog, string(content)) } @@ -1294,7 +1293,7 @@ func TestStringVariation(t *testing.T) { for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { // init logger - file, _ := ioutil.TempFile("", "log") + file, _ := os.CreateTemp("", "log") logger := log.New(file, "", 0) ff = &GoFeatureFlag{ @@ -1314,7 +1313,7 @@ func TestStringVariation(t *testing.T) { got, err := StringVariation(tt.args.flagKey, tt.args.user, tt.args.defaultValue) if tt.expectedLog != "" { - content, _ := ioutil.ReadFile(file.Name()) + content, _ := os.ReadFile(file.Name()) assert.Regexp(t, tt.expectedLog, string(content)) } @@ -1565,7 +1564,7 @@ func TestIntVariation(t *testing.T) { for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { // init logger - file, _ := ioutil.TempFile("", "log") + file, _ := os.CreateTemp("", "log") logger := log.New(file, "", 0) ff = &GoFeatureFlag{ @@ -1585,7 +1584,7 @@ func TestIntVariation(t *testing.T) { got, err := IntVariation(tt.args.flagKey, tt.args.user, tt.args.defaultValue) if tt.expectedLog != "" { - content, _ := ioutil.ReadFile(file.Name()) + content, _ := os.ReadFile(file.Name()) assert.Regexp(t, tt.expectedLog, string(content)) } @@ -1659,7 +1658,7 @@ func TestAllFlagsState(t *testing.T) { for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { // init logger - exportDir, _ := ioutil.TempDir("", "export") + exportDir, _ := os.MkdirTemp("", "export") tt.config.DataExporter = DataExporter{ FlushInterval: 1000, MaxEventInMemory: 1, @@ -1683,7 +1682,7 @@ func TestAllFlagsState(t *testing.T) { assert.Equal(t, tt.valid, allFlagsState.IsValid()) // expected JSON output - we force the timestamp - expected, _ := ioutil.ReadFile(tt.jsonOutput) + expected, _ := os.ReadFile(tt.jsonOutput) var f map[string]interface{} _ = json.Unmarshal(expected, &f) if expectedFlags, ok := f["flags"].(map[string]interface{}); ok { @@ -2026,7 +2025,7 @@ func TestRawVariation(t *testing.T) { for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { // init logger - file, _ := ioutil.TempFile("", "log") + file, _ := os.CreateTemp("", "log") logger := log.New(file, "", 0) ff = &GoFeatureFlag{ @@ -2047,7 +2046,7 @@ func TestRawVariation(t *testing.T) { got, err := ff.RawVariation(tt.args.flagKey, tt.args.user, tt.args.defaultValue) if tt.expectedLog != "" { - content, _ := ioutil.ReadFile(file.Name()) + content, _ := os.ReadFile(file.Name()) assert.Regexp(t, tt.expectedLog, string(content)) } From 724f0744da8c1de143e0ead8dffcf671fcfd0603 Mon Sep 17 00:00:00 2001 From: Thomas Poignant Date: Tue, 9 Aug 2022 13:49:15 +0200 Subject: [PATCH 31/50] Add godoc Signed-off-by: Thomas Poignant --- internal/flag/rollout_progressive.go | 11 ++++++++--- 1 file changed, 8 insertions(+), 3 deletions(-) diff --git a/internal/flag/rollout_progressive.go b/internal/flag/rollout_progressive.go index 8b6d1290ebc..40c38bc1d2a 100644 --- a/internal/flag/rollout_progressive.go +++ b/internal/flag/rollout_progressive.go @@ -15,9 +15,14 @@ type ProgressiveRollout struct { // ProgressiveRolloutStep define a progressive rollout step (initial and end) type ProgressiveRolloutStep struct { - Variation *string - Percentage *float64 - Date *time.Time + // Variation - name of the variation for this step + Variation *string `json:"variation,omitempty" yaml:"variation,omitempty" toml:"variation,omitempty"` + + // Percentage is the percentage (initial or end) for the progressive rollout + Percentage *float64 `json:"percentage,omitempty" yaml:"percentage,omitempty" toml:"percentage,omitempty"` + + // Date is the time it starts or ends. + Date *time.Time `json:"date,omitempty" yaml:"date,omitempty" toml:"date,omitempty"` } func (p *ProgressiveRolloutStep) getVariation() string { From 5dfc143c257ae8051f78810a223eb932cdb8277b Mon Sep 17 00:00:00 2001 From: Thomas Poignant Date: Tue, 9 Aug 2022 22:57:45 +0200 Subject: [PATCH 32/50] Change TOML lib to use BurntSushi/toml Signed-off-by: Thomas Poignant --- cmd/migrationcli/converter.go | 16 +- go.mod | 2 +- go.sum | 7 +- internal/cache/cache_manager.go | 4 +- internal/dto/dto_rollout.go | 25 ++- internal/dto/dto_rollout_test.go | 270 ++++++++++++++++++++++++++ testdata/internal/dto/rollout.json | 20 ++ testdata/internal/dto/rollout.toml | 15 ++ testdata/internal/dto/rollout.yaml | 10 + testdata/internal/dto/rollout_v0.json | 19 ++ testdata/internal/dto/rollout_v0.toml | 12 ++ testdata/internal/dto/rollout_v0.yaml | 11 ++ 12 files changed, 397 insertions(+), 14 deletions(-) create mode 100644 internal/dto/dto_rollout_test.go create mode 100644 testdata/internal/dto/rollout.json create mode 100644 testdata/internal/dto/rollout.toml create mode 100644 testdata/internal/dto/rollout.yaml create mode 100644 testdata/internal/dto/rollout_v0.json create mode 100644 testdata/internal/dto/rollout_v0.toml create mode 100644 testdata/internal/dto/rollout_v0.yaml diff --git a/cmd/migrationcli/converter.go b/cmd/migrationcli/converter.go index 847d9d7b614..179738ff59c 100644 --- a/cmd/migrationcli/converter.go +++ b/cmd/migrationcli/converter.go @@ -1,12 +1,14 @@ package main import ( + "bytes" "encoding/json" "fmt" "os" "strings" - "github.com/pelletier/go-toml" + "github.com/BurntSushi/toml" + "github.com/thomaspoignant/go-feature-flag/internal/dto" "github.com/thomaspoignant/go-feature-flag/internal/flag" "gopkg.in/yaml.v3" @@ -27,12 +29,12 @@ func (f *FlagConverter) Migrate() error { return fmt.Errorf("file %v is impossible to find", f.InputFile) } - flags, err := f.marshall(content) + flags, err := f.unmarshall(content) if err != nil { return err } - newFileContent, err := f.unmarshall(f.convert(flags)) + newFileContent, err := f.marshall(f.convert(flags)) if err != nil { return err } @@ -45,7 +47,7 @@ func (f *FlagConverter) Migrate() error { return nil } -func (f *FlagConverter) marshall(content []byte) (map[string]dto.DTO, error) { +func (f *FlagConverter) unmarshall(content []byte) (map[string]dto.DTO, error) { var flags map[string]dto.DTO switch strings.ToLower(f.InputFormat) { case "toml": @@ -75,10 +77,12 @@ func (f *FlagConverter) convert(flags map[string]dto.DTO) map[string]flag.Intern return convertedFlags } -func (f *FlagConverter) unmarshall(convertedFlags map[string]flag.InternalFlag) ([]byte, error) { +func (f *FlagConverter) marshall(convertedFlags map[string]flag.InternalFlag) ([]byte, error) { switch strings.ToLower(f.OutputFormat) { case "toml": - return toml.Marshal(convertedFlags) + buf := new(bytes.Buffer) + _ = toml.NewEncoder(buf).Encode(convertedFlags) + return buf.Bytes(), nil case "json": return json.Marshal(convertedFlags) default: diff --git a/go.mod b/go.mod index 102fff94f0e..45790744a34 100644 --- a/go.mod +++ b/go.mod @@ -4,13 +4,13 @@ go 1.17 require ( cloud.google.com/go/storage v1.24.0 + github.com/BurntSushi/toml v1.2.0 github.com/aws/aws-sdk-go v1.44.70 github.com/gdexlab/go-render v1.0.1 github.com/golang/mock v1.6.0 github.com/google/go-cmp v0.5.8 github.com/jessevdk/go-flags v1.5.0 github.com/nikunjy/rules v1.1.0 - github.com/pelletier/go-toml v1.9.5 github.com/r3labs/diff/v3 v3.0.0 github.com/stretchr/testify v1.8.0 golang.org/x/oauth2 v0.0.0-20220622183110-fd043fe589d2 diff --git a/go.sum b/go.sum index f970258eca6..8fee8822080 100644 --- a/go.sum +++ b/go.sum @@ -68,6 +68,8 @@ github.com/Azure/go-autorest/autorest/mocks v0.4.1/go.mod h1:LTp+uSrOhSkaKrUy935 github.com/Azure/go-autorest/logger v0.2.1/go.mod h1:T9E3cAhj2VqvPOtCYAvby9aBXkZmbF5NWuPV8+WeEW8= github.com/Azure/go-autorest/tracing v0.6.0/go.mod h1:+vhtPC754Xsa23ID7GlGsrdKBpUA79WCAKPPZVC2DeU= github.com/BurntSushi/toml v0.3.1/go.mod h1:xHWCNGjB5oqiDr8zfno3MHue2Ht5sIBksp03qcyfWMU= +github.com/BurntSushi/toml v1.2.0 h1:Rt8g24XnyGTyglgET/PRUNlrUeu9F5L+7FilkXfZgs0= +github.com/BurntSushi/toml v1.2.0/go.mod h1:CxXYINrC8qIiEnFrOxCa7Jy5BFHlXnUU2pbicEuybxQ= github.com/BurntSushi/xgb v0.0.0-20160522181843-27f122750802/go.mod h1:IVnqGOEym/WlBOVXweHU+Q+/VP0lqqI8lqeDx9IjBqo= github.com/NYTimes/gziphandler v0.0.0-20170623195520-56545f4a5d46/go.mod h1:3wb06e3pkSAbeQ52E9H9iFoQsEEwGN64994WTCIhntQ= github.com/OneOfOne/xxhash v1.2.2/go.mod h1:HSdplMjZKSmBqAxg5vPj2TmRDmfkzw+cTzAElWljhcU= @@ -305,8 +307,8 @@ github.com/onsi/gomega v0.0.0-20170829124025-dcabb60a477c/go.mod h1:C1qb7wdrVGGV github.com/onsi/gomega v1.7.1/go.mod h1:XdKZgCCFLUoM/7CFJVPcG8C1xQ1AJ0vpAezJrB7JYyY= github.com/onsi/gomega v1.10.1 h1:o0+MgICZLuZ7xjH7Vx6zS/zcu93/BEp1VwkIW1mEXCE= github.com/onsi/gomega v1.10.1/go.mod h1:iN09h71vgCQne3DLsj+A5owkum+a2tYe+TOCB1ybHNo= -github.com/pelletier/go-toml v1.9.5 h1:4yBQzkHv+7BHq2PQUZF3Mx0IYxG7LsP222s7Agd3ve8= -github.com/pelletier/go-toml v1.9.5/go.mod h1:u1nR/EPcESfeI/szUZKdtJ0xRNbUoANCkoOuaOx1Y+c= +github.com/pelletier/go-toml/v2 v2.0.2 h1:+jQXlF3scKIcSEKkdHzXhCTDLPFi5r1wnK6yPS+49Gw= +github.com/pelletier/go-toml/v2 v2.0.2/go.mod h1:MovirKjgVRESsAvNZlAjtFwV867yGuwRkXbG66OzopI= github.com/peterbourgon/diskv v2.0.1+incompatible/go.mod h1:uqqh8zWWbv1HBMNONnaR/tNboyR3/BZd58JJSHlUSCU= github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4= github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0= @@ -330,6 +332,7 @@ github.com/stretchr/testify v1.5.1/go.mod h1:5W2xD1RspED5o8YsWQXVCued0rvSQ+mT+I5 github.com/stretchr/testify v1.6.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= +github.com/stretchr/testify v1.7.2/go.mod h1:R6va5+xMeoiuVRoj+gSkQ7d3FALtqAAGI1FQKckRals= github.com/stretchr/testify v1.8.0 h1:pSgiaMZlXftHpm5L7V1+rVB+AZJydKsMxsQBIJw4PKk= github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU= github.com/vmihailenco/msgpack v4.0.4+incompatible h1:dSLoQfGFAo3F6OoNhwUmLwVgaUXK79GlxNBwueZn0xI= diff --git a/internal/cache/cache_manager.go b/internal/cache/cache_manager.go index 7c5756c680d..dda0a7ad115 100644 --- a/internal/cache/cache_manager.go +++ b/internal/cache/cache_manager.go @@ -8,12 +8,12 @@ import ( "sync" "time" + "github.com/BurntSushi/toml" + "github.com/thomaspoignant/go-feature-flag/internal/dto" "github.com/thomaspoignant/go-feature-flag/internal/flag" "gopkg.in/yaml.v3" - - "github.com/pelletier/go-toml" ) type Manager interface { diff --git a/internal/dto/dto_rollout.go b/internal/dto/dto_rollout.go index 2931e209893..943dd48c29b 100644 --- a/internal/dto/dto_rollout.go +++ b/internal/dto/dto_rollout.go @@ -67,17 +67,36 @@ func (p *Rollout) UnmarshalJSON(data []byte) error { var v1 V1Rollout // we ignore the unmarshal errors because they are expected since we have multiple format - _ = json.Unmarshal(data, &v1) - p.V1Rollout = v1 + err = json.Unmarshal(data, &v1) + if err != nil { + // TODO: add log in debug only + } + if v1.Scheduled != nil && *v1.Scheduled != nil { + p.V1Rollout = v1 + } var v0 V0Rollout // we ignore the unmarshal errors because they are expected since we have multiple format - _ = json.Unmarshal(data, &v0) + err = json.Unmarshal(data, &v0) + if err != nil { + // TODO: add log in debug only + } p.V0Rollout = v0 return nil } +// UnmarshalTOML is used for TOML unmarshalling, the lib is not calling directly UnmarshalJSON, +// so we are calling it after marshaling input in JSON string +func (p *Rollout) UnmarshalTOML(input interface{}) error { + jsonStr, err := json.Marshal(input) + if err != nil { + // TODO: add log in debug only + return err + } + return p.UnmarshalJSON(jsonStr) +} + type ScheduledRolloutV0 struct { // Steps is the list of updates to do in a specific date. Steps []ScheduledStepV0 `json:"steps,omitempty" yaml:"steps,omitempty" toml:"steps,omitempty"` diff --git a/internal/dto/dto_rollout_test.go b/internal/dto/dto_rollout_test.go new file mode 100644 index 00000000000..9bb8445bba9 --- /dev/null +++ b/internal/dto/dto_rollout_test.go @@ -0,0 +1,270 @@ +package dto_test + +import ( + "encoding/json" + "os" + "strings" + "testing" + "time" + + "github.com/google/go-cmp/cmp" + + "github.com/BurntSushi/toml" + + "github.com/thomaspoignant/go-feature-flag/internal/flag" + + "github.com/thomaspoignant/go-feature-flag/testutils/testconvert" + + "github.com/thomaspoignant/go-feature-flag/internal/dto" + "k8s.io/apimachinery/pkg/util/yaml" + + "github.com/stretchr/testify/assert" +) + +func TestRollout_UnmarshalJSON(t *testing.T) { + tests := []struct { + name string + input string + fileType string + want dto.Rollout + wantErr assert.ErrorAssertionFunc + }{ + { + name: "Should unmarshal valid JSON file", + input: "../../testdata/internal/dto/rollout.json", + fileType: "json", + want: dto.Rollout{ + V1Rollout: dto.V1Rollout{ + Scheduled: &[]flag.ScheduledStep{ + { + Date: testconvert.Time(time.Date(2021, time.February, 1, 10, 10, 10, 10, time.UTC)), + InternalFlag: flag.InternalFlag{ + Variations: &map[string]*interface{}{ + "VariationDefault": testconvert.Interface(true), + }, + }, + }, + { + Date: testconvert.Time(time.Date(2021, time.February, 2, 10, 10, 10, 10, time.UTC)), + InternalFlag: flag.InternalFlag{ + Variations: &map[string]*interface{}{ + "VariationDefault": testconvert.Interface(false), + }, + }, + }, + }, + }, + V0Rollout: dto.V0Rollout{Scheduled: &dto.ScheduledRolloutV0{}}, + CommonRollout: dto.CommonRollout{ + Experimentation: &dto.ExperimentationDto{ + Start: testconvert.Time(time.Date(2021, time.February, 1, 10, 10, 10, 10, time.UTC)), + End: testconvert.Time(time.Date(2021, time.March, 1, 10, 10, 10, 10, time.UTC)), + }, + Progressive: nil, + }, + }, + wantErr: assert.NoError, + }, + { + name: "Should unmarshal valid TOML file", + input: "../../testdata/internal/dto/rollout.toml", + fileType: "toml", + want: dto.Rollout{ + V1Rollout: dto.V1Rollout{ + Scheduled: &[]flag.ScheduledStep{ + { + Date: testconvert.Time(time.Date(2021, time.February, 1, 10, 10, 10, 10, time.UTC)), + InternalFlag: flag.InternalFlag{ + Variations: &map[string]*interface{}{ + "VariationDefault": testconvert.Interface(true), + }, + }, + }, + { + Date: testconvert.Time(time.Date(2021, time.February, 2, 10, 10, 10, 10, time.UTC)), + InternalFlag: flag.InternalFlag{ + Variations: &map[string]*interface{}{ + "VariationDefault": testconvert.Interface(false), + }, + }, + }, + }, + }, + V0Rollout: dto.V0Rollout{Scheduled: &dto.ScheduledRolloutV0{}}, + CommonRollout: dto.CommonRollout{ + Experimentation: &dto.ExperimentationDto{ + Start: testconvert.Time(time.Date(2021, time.February, 1, 10, 10, 10, 10, time.UTC)), + End: testconvert.Time(time.Date(2021, time.March, 1, 10, 10, 10, 10, time.UTC)), + }, + Progressive: nil, + }, + }, + wantErr: assert.NoError, + }, + { + name: "Should unmarshal valid YAML file", + input: "../../testdata/internal/dto/rollout.yaml", + fileType: "yaml", + want: dto.Rollout{ + V1Rollout: dto.V1Rollout{ + Scheduled: &[]flag.ScheduledStep{ + { + Date: testconvert.Time(time.Date(2021, time.February, 1, 10, 10, 10, 10, time.UTC)), + InternalFlag: flag.InternalFlag{ + Variations: &map[string]*interface{}{ + "VariationDefault": testconvert.Interface(true), + }, + }, + }, + { + Date: testconvert.Time(time.Date(2021, time.February, 2, 10, 10, 10, 10, time.UTC)), + InternalFlag: flag.InternalFlag{ + Variations: &map[string]*interface{}{ + "VariationDefault": testconvert.Interface(false), + }, + }, + }, + }, + }, + V0Rollout: dto.V0Rollout{Scheduled: &dto.ScheduledRolloutV0{}}, + CommonRollout: dto.CommonRollout{ + Experimentation: &dto.ExperimentationDto{ + Start: testconvert.Time(time.Date(2021, time.February, 1, 10, 10, 10, 10, time.UTC)), + End: testconvert.Time(time.Date(2021, time.March, 1, 10, 10, 10, 10, time.UTC)), + }, + Progressive: nil, + }, + }, + wantErr: assert.NoError, + }, + { + name: "Should unmarshal valid JSON file with v0 rollout", + input: "../../testdata/internal/dto/rollout_v0.json", + fileType: "JSON", + want: dto.Rollout{ + V0Rollout: dto.V0Rollout{Scheduled: &dto.ScheduledRolloutV0{ + Steps: []dto.ScheduledStepV0{ + { + DTO: dto.DTO{ + DTOv0: dto.DTOv0{ + Rule: testconvert.String("beta eq \"true\""), + Percentage: testconvert.Float64(100), + }, + }, + Date: testconvert.Time(time.Date(2021, time.February, 2, 10, 10, 10, 10, time.UTC)), + }, + { + DTO: dto.DTO{ + DTOv0: dto.DTOv0{ + Rule: testconvert.String("beta eq \"false\""), + }, + }, + Date: testconvert.Time(time.Date(2021, time.February, 2, 10, 10, 10, 10, time.UTC)), + }, + }, + }}, + CommonRollout: dto.CommonRollout{ + Experimentation: &dto.ExperimentationDto{ + Start: testconvert.Time(time.Date(2021, time.February, 1, 10, 10, 10, 10, time.UTC)), + End: testconvert.Time(time.Date(2021, time.March, 1, 10, 10, 10, 10, time.UTC)), + }, + Progressive: nil, + }, + }, + wantErr: assert.NoError, + }, + { + name: "Should unmarshal valid TOML file with v0 rollout", + input: "../../testdata/internal/dto/rollout_v0.toml", + fileType: "TOML", + want: dto.Rollout{ + V0Rollout: dto.V0Rollout{Scheduled: &dto.ScheduledRolloutV0{ + Steps: []dto.ScheduledStepV0{ + { + DTO: dto.DTO{ + DTOv0: dto.DTOv0{ + Rule: testconvert.String("beta eq \"true\""), + Percentage: testconvert.Float64(100), + }, + }, + Date: testconvert.Time(time.Date(2021, time.February, 2, 10, 10, 10, 10, time.UTC)), + }, + { + DTO: dto.DTO{ + DTOv0: dto.DTOv0{ + Rule: testconvert.String("beta eq \"false\""), + }, + }, + Date: testconvert.Time(time.Date(2021, time.February, 2, 10, 10, 10, 10, time.UTC)), + }, + }, + }}, + CommonRollout: dto.CommonRollout{ + Experimentation: &dto.ExperimentationDto{ + Start: testconvert.Time(time.Date(2021, time.February, 1, 10, 10, 10, 10, time.UTC)), + End: testconvert.Time(time.Date(2021, time.March, 1, 10, 10, 10, 10, time.UTC)), + }, + Progressive: nil, + }, + }, + wantErr: assert.NoError, + }, + { + name: "Should unmarshal valid YAML file with v0 rollout", + input: "../../testdata/internal/dto/rollout_v0.yaml", + fileType: "YAML", + want: dto.Rollout{ + V0Rollout: dto.V0Rollout{Scheduled: &dto.ScheduledRolloutV0{ + Steps: []dto.ScheduledStepV0{ + { + DTO: dto.DTO{ + DTOv0: dto.DTOv0{ + Rule: testconvert.String("beta eq \"true\""), + Percentage: testconvert.Float64(100), + }, + }, + Date: testconvert.Time(time.Date(2021, time.February, 2, 10, 10, 10, 10, time.UTC)), + }, + { + DTO: dto.DTO{ + DTOv0: dto.DTOv0{ + Rule: testconvert.String("beta eq \"false\""), + }, + }, + Date: testconvert.Time(time.Date(2021, time.February, 2, 10, 10, 10, 10, time.UTC)), + }, + }, + }}, + CommonRollout: dto.CommonRollout{ + Experimentation: &dto.ExperimentationDto{ + Start: testconvert.Time(time.Date(2021, time.February, 1, 10, 10, 10, 10, time.UTC)), + End: testconvert.Time(time.Date(2021, time.March, 1, 10, 10, 10, 10, time.UTC)), + }, + Progressive: nil, + }, + }, + wantErr: assert.NoError, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + var err error + var r dto.Rollout + content, err := os.ReadFile(tt.input) + assert.NoError(t, err, "impossible to find input test file %v", tt.input) + + switch strings.ToLower(tt.fileType) { + case "toml": + _, err = toml.Decode(string(content), &r) + case "json": + err = json.Unmarshal(content, &r) + case "yaml": + err = yaml.Unmarshal(content, &r) + default: + panic("not expected") + } + tt.wantErr(t, err) + assert.Equal(t, tt.want, r, cmp.Diff(tt.want, r)) + }) + } +} diff --git a/testdata/internal/dto/rollout.json b/testdata/internal/dto/rollout.json new file mode 100644 index 00000000000..3573340154c --- /dev/null +++ b/testdata/internal/dto/rollout.json @@ -0,0 +1,20 @@ +{ + "scheduled": [ + { + "date": "2021-02-01T10:10:10.00000001Z", + "variations": { + "VariationDefault": true + } + }, + { + "date": "2021-02-02T10:10:10.00000001Z", + "variations": { + "VariationDefault": false + } + } + ], + "experimentation": { + "start": "2021-02-01T10:10:10.00000001Z", + "end": "2021-03-01T10:10:10.00000001Z" + } +} diff --git a/testdata/internal/dto/rollout.toml b/testdata/internal/dto/rollout.toml new file mode 100644 index 00000000000..8316cf69583 --- /dev/null +++ b/testdata/internal/dto/rollout.toml @@ -0,0 +1,15 @@ +[[scheduled]] +date = "2021-02-01T10:10:10.00000001Z" + +[scheduled.variations] +VariationDefault = true + +[[scheduled]] +date = "2021-02-02T10:10:10.00000001Z" + +[scheduled.variations] +VariationDefault = false + +[experimentation] +start = "2021-02-01T10:10:10.00000001Z" +end = "2021-03-01T10:10:10.00000001Z" diff --git a/testdata/internal/dto/rollout.yaml b/testdata/internal/dto/rollout.yaml new file mode 100644 index 00000000000..9b6be2d7f4a --- /dev/null +++ b/testdata/internal/dto/rollout.yaml @@ -0,0 +1,10 @@ +scheduled: + - date: '2021-02-01T10:10:10.00000001Z' + variations: + VariationDefault: true + - date: '2021-02-02T10:10:10.00000001Z' + variations: + VariationDefault: false +experimentation: + start: '2021-02-01T10:10:10.00000001Z' + end: '2021-03-01T10:10:10.00000001Z' diff --git a/testdata/internal/dto/rollout_v0.json b/testdata/internal/dto/rollout_v0.json new file mode 100644 index 00000000000..c5e621aec28 --- /dev/null +++ b/testdata/internal/dto/rollout_v0.json @@ -0,0 +1,19 @@ +{ + "scheduled": { + "steps": [ + { + "date": "2021-02-02T10:10:10.00000001Z", + "rule": "beta eq \"true\"", + "percentage": 100 + }, + { + "date": "2021-02-02T10:10:10.00000001Z", + "rule": "beta eq \"false\"" + } + ] + }, + "experimentation": { + "start": "2021-02-01T10:10:10.00000001Z", + "end": "2021-03-01T10:10:10.00000001Z" + } +} diff --git a/testdata/internal/dto/rollout_v0.toml b/testdata/internal/dto/rollout_v0.toml new file mode 100644 index 00000000000..e2c029a84ff --- /dev/null +++ b/testdata/internal/dto/rollout_v0.toml @@ -0,0 +1,12 @@ +[[scheduled.steps]] +date = "2021-02-02T10:10:10.00000001Z" +rule = 'beta eq "true"' +percentage = 100 + +[[scheduled.steps]] +date = "2021-02-02T10:10:10.00000001Z" +rule = 'beta eq "false"' + +[experimentation] +start = "2021-02-01T10:10:10.00000001Z" +end = "2021-03-01T10:10:10.00000001Z" diff --git a/testdata/internal/dto/rollout_v0.yaml b/testdata/internal/dto/rollout_v0.yaml new file mode 100644 index 00000000000..351914eb380 --- /dev/null +++ b/testdata/internal/dto/rollout_v0.yaml @@ -0,0 +1,11 @@ +scheduled: + steps: + - date: '2021-02-02T10:10:10.00000001Z' + rule: beta eq "true" + percentage: 100 + - date: '2021-02-02T10:10:10.00000001Z' + rule: beta eq "false" + +experimentation: + start: '2021-02-01T10:10:10.00000001Z' + end: '2021-03-01T10:10:10.00000001Z' From 61968c93aef989428ead625700c1df274c459d22 Mon Sep 17 00:00:00 2001 From: Thomas Poignant Date: Tue, 9 Aug 2022 23:29:52 +0200 Subject: [PATCH 33/50] Add test for new flag format Signed-off-by: Thomas Poignant --- ...converter_v0_test.go => converter_test.go} | 135 ++++++++++++++++-- internal/dto/dto.go | 2 +- 2 files changed, 126 insertions(+), 11 deletions(-) rename internal/dto/{converter_v0_test.go => converter_test.go} (87%) diff --git a/internal/dto/converter_v0_test.go b/internal/dto/converter_test.go similarity index 87% rename from internal/dto/converter_v0_test.go rename to internal/dto/converter_test.go index 7ac92f7b5fa..41d97a665d3 100644 --- a/internal/dto/converter_v0_test.go +++ b/internal/dto/converter_test.go @@ -20,7 +20,11 @@ func TestConvertV0DtoToInternalFlag(t *testing.T) { want flag.InternalFlag }{ { - name: "Simplest flag, no converter provided", + name: "Should return empty if flag dto is nil", + want: flag.InternalFlag{}, + }, + { + name: "[v0] Simplest flag, no converter provided", d: dto.DTO{DTOv0: dto.DTOv0{ True: testconvert.Interface("true"), False: testconvert.Interface("false"), @@ -43,7 +47,7 @@ func TestConvertV0DtoToInternalFlag(t *testing.T) { }, }, { - name: "Flag with percentage", + name: "[v0] Flag with percentage", d: dto.DTO{DTOv0: dto.DTOv0{ Percentage: testconvert.Float64(10), True: testconvert.Interface("true"), @@ -66,7 +70,7 @@ func TestConvertV0DtoToInternalFlag(t *testing.T) { }, }, { - name: "Flag with 100 percentage", + name: "[v0] Flag with 100 percentage", d: dto.DTO{DTOv0: dto.DTOv0{ Percentage: testconvert.Float64(100), True: testconvert.Interface("true"), @@ -90,7 +94,7 @@ func TestConvertV0DtoToInternalFlag(t *testing.T) { }, }, { - name: "Flag with rule not match", + name: "[v0] Flag with rule not match", d: dto.DTO{DTOv0: dto.DTOv0{ Rule: testconvert.String("key eq \"random\""), True: testconvert.Interface("true"), @@ -120,7 +124,7 @@ func TestConvertV0DtoToInternalFlag(t *testing.T) { }, }, { - name: "Flag with rule match", + name: "[v0] Flag with rule match", d: dto.DTO{DTOv0: dto.DTOv0{ Rule: testconvert.String("key eq \"test-user\""), True: testconvert.Interface("true"), @@ -150,7 +154,7 @@ func TestConvertV0DtoToInternalFlag(t *testing.T) { }, }, { - name: "Flag with rule match + 10% percentage", + name: "[v0] Flag with rule match + 10% percentage", d: dto.DTO{DTOv0: dto.DTOv0{ Rule: testconvert.String("key eq \"test-user\""), Percentage: testconvert.Float64(10), @@ -181,7 +185,7 @@ func TestConvertV0DtoToInternalFlag(t *testing.T) { }, }, { - name: "Flag with query + experimentation rollout", + name: "[v0] Flag with query + experimentation rollout", d: dto.DTO{ DTOv0: dto.DTOv0{ Rule: testconvert.String("key eq \"test-user\""), @@ -228,7 +232,7 @@ func TestConvertV0DtoToInternalFlag(t *testing.T) { }, }, { - name: "Flag with query + progressive rollout", + name: "[v0] Flag with query + progressive rollout", d: dto.DTO{ DTOv0: dto.DTOv0{ Rule: testconvert.String("key eq \"test-user\""), @@ -283,7 +287,7 @@ func TestConvertV0DtoToInternalFlag(t *testing.T) { }, }, { - name: "Flag without query + progressive rollout", + name: "[v0] Flag without query + progressive rollout", d: dto.DTO{ DTOv0: dto.DTOv0{ True: testconvert.Interface("true"), @@ -328,10 +332,121 @@ func TestConvertV0DtoToInternalFlag(t *testing.T) { }, }, }, + { + name: "[v1] Complete and complex flag v1", + d: dto.DTO{ + DTOv1: dto.DTOv1{ + Variations: &map[string]*interface{}{ + "VariationDefault": testconvert.Interface(false), + "VariationBar": testconvert.Interface(false), + "VariationFoo": testconvert.Interface(true), + }, + Rules: &[]flag.Rule{ + { + Name: testconvert.String("rule-number-1"), + Query: testconvert.String("key eq \"random-key\""), + Percentages: &map[string]float64{ + "VariationBar": 0, + "VariationFoo": 100, + }, + }, + { + Name: testconvert.String("rule-number-2"), + Query: testconvert.String("key eq \"other-random-key\""), + ProgressiveRollout: &flag.ProgressiveRollout{ + Initial: &flag.ProgressiveRolloutStep{ + Variation: testconvert.String("VariationBar"), + Percentage: testconvert.Float64(0), + Date: testconvert.Time(time.Date(2021, time.February, 1, 10, 10, 10, 10, time.UTC)), + }, + End: &flag.ProgressiveRolloutStep{ + Variation: testconvert.String("VariationFoo"), + Percentage: testconvert.Float64(100), + Date: testconvert.Time(time.Date(2021, time.February, 2, 10, 10, 10, 10, time.UTC)), + }, + }, + }, + }, + DefaultRule: &flag.Rule{ + VariationResult: testconvert.String("VariationDefault"), + }, + }, + Rollout: &dto.Rollout{ + CommonRollout: dto.CommonRollout{ + Experimentation: &dto.ExperimentationDto{ + Start: testconvert.Time(time.Date(2021, time.February, 1, 10, 10, 10, 10, time.UTC)), + End: testconvert.Time(time.Date(2021, time.February, 2, 10, 10, 10, 10, time.UTC)), + }, + }, + V1Rollout: dto.V1Rollout{Scheduled: &[]flag.ScheduledStep{ + { + InternalFlag: flag.InternalFlag{ + Variations: &map[string]*interface{}{ + "VariationDefault": testconvert.Interface(true), + }, + }, + Date: testconvert.Time(time.Date(2021, time.February, 2, 10, 10, 10, 10, time.UTC)), + }, + }}, + }, + }, + want: flag.InternalFlag{ + Variations: &map[string]*interface{}{ + "VariationDefault": testconvert.Interface(false), + "VariationBar": testconvert.Interface(false), + "VariationFoo": testconvert.Interface(true), + }, + Rules: &[]flag.Rule{ + { + Name: testconvert.String("rule-number-1"), + Query: testconvert.String("key eq \"random-key\""), + Percentages: &map[string]float64{ + "VariationBar": 0, + "VariationFoo": 100, + }, + }, + { + Name: testconvert.String("rule-number-2"), + Query: testconvert.String("key eq \"other-random-key\""), + ProgressiveRollout: &flag.ProgressiveRollout{ + Initial: &flag.ProgressiveRolloutStep{ + Variation: testconvert.String("VariationBar"), + Percentage: testconvert.Float64(0), + Date: testconvert.Time(time.Date(2021, time.February, 1, 10, 10, 10, 10, time.UTC)), + }, + End: &flag.ProgressiveRolloutStep{ + Variation: testconvert.String("VariationFoo"), + Percentage: testconvert.Float64(100), + Date: testconvert.Time(time.Date(2021, time.February, 2, 10, 10, 10, 10, time.UTC)), + }, + }, + }, + }, + DefaultRule: &flag.Rule{ + VariationResult: testconvert.String("VariationDefault"), + }, + Rollout: &flag.Rollout{ + Experimentation: &flag.ExperimentationRollout{ + Start: testconvert.Time(time.Date(2021, time.February, 1, 10, 10, 10, 10, time.UTC)), + End: testconvert.Time(time.Date(2021, time.February, 2, 10, 10, 10, 10, time.UTC)), + }, + Scheduled: &[]flag.ScheduledStep{ + { + InternalFlag: flag.InternalFlag{ + Variations: &map[string]*interface{}{ + "VariationDefault": testconvert.Interface(true), + }, + }, + Date: testconvert.Time(time.Date(2021, time.February, 2, 10, 10, 10, 10, time.UTC)), + }, + }, + }, + }, + }, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { - assert.Equal(t, tt.want, dto.ConvertV0DtoToInternalFlag(tt.d, false)) + assert.Equal(t, tt.want, tt.d.Convert()) }) } } diff --git a/internal/dto/dto.go b/internal/dto/dto.go index f87fe981fb4..27da61558bb 100644 --- a/internal/dto/dto.go +++ b/internal/dto/dto.go @@ -70,7 +70,7 @@ type DTOv0 struct { } func (d *DTO) Convert() flag.InternalFlag { - if d == nil { + if d == nil || (DTO{}) == *d { return flag.InternalFlag{} } if (d.Converter != nil && *d.Converter == "v0") || d.True != nil || d.False != nil { From 54e73013312c3d59f5c383d71c9ccf2791f6a90c Mon Sep 17 00:00:00 2001 From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com> Date: Fri, 9 Sep 2022 04:12:43 +0000 Subject: [PATCH 34/50] Bump github.com/google/go-cmp from 0.5.8 to 0.5.9 (#335) Bumps [github.com/google/go-cmp](https://github.com/google/go-cmp) from 0.5.8 to 0.5.9. - [Release notes](https://github.com/google/go-cmp/releases) - [Commits](https://github.com/google/go-cmp/compare/v0.5.8...v0.5.9) --- updated-dependencies: - dependency-name: github.com/google/go-cmp dependency-type: direct:production update-type: version-update:semver-patch ... Signed-off-by: dependabot[bot] Signed-off-by: dependabot[bot] Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com> --- go.sum | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/go.sum b/go.sum index ddba8cc01ae..95e9fb54379 100644 --- a/go.sum +++ b/go.sum @@ -220,8 +220,9 @@ github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/ github.com/google/go-cmp v0.5.5/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.7/go.mod h1:n+brtR0CgQNWTVd5ZUFpTBC8YFBDLK/h/bpaJ8/DtOE= -github.com/google/go-cmp v0.5.8 h1:e6P7q2lk1O+qJJb4BtCQXlK8vWEO8V1ZeuEdJNOqZyg= github.com/google/go-cmp v0.5.8/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY= +github.com/google/go-cmp v0.5.9 h1:O2Tfq5qg4qc4AmwVlvv0oLiVAGB7enBSJ2x2DqQFi38= +github.com/google/go-cmp v0.5.9/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY= github.com/google/gofuzz v1.0.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg= github.com/google/gofuzz v1.1.0 h1:Hsa8mG0dQ46ij8Sl2AYJDUv1oA9/d6Vk+3LG99Oe02g= github.com/google/gofuzz v1.1.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg= From f0964c87ed47317c4db0181196bd1c9af5aa4b0c Mon Sep 17 00:00:00 2001 From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com> Date: Fri, 9 Sep 2022 04:19:01 +0000 Subject: [PATCH 35/50] Bump github.com/aws/aws-sdk-go from 1.44.93 to 1.44.94 (#336) Bumps [github.com/aws/aws-sdk-go](https://github.com/aws/aws-sdk-go) from 1.44.93 to 1.44.94. - [Release notes](https://github.com/aws/aws-sdk-go/releases) - [Changelog](https://github.com/aws/aws-sdk-go/blob/main/CHANGELOG.md) - [Commits](https://github.com/aws/aws-sdk-go/compare/v1.44.93...v1.44.94) --- updated-dependencies: - dependency-name: github.com/aws/aws-sdk-go dependency-type: direct:production update-type: version-update:semver-patch ... Signed-off-by: dependabot[bot] Signed-off-by: dependabot[bot] Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com> Co-authored-by: kodiakhq[bot] <49736102+kodiakhq[bot]@users.noreply.github.com> --- go.mod | 2 +- go.sum | 4 ++-- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/go.mod b/go.mod index b28ac996d57..fb3c08d505a 100644 --- a/go.mod +++ b/go.mod @@ -5,7 +5,7 @@ go 1.17 require ( cloud.google.com/go/storage v1.26.0 github.com/BurntSushi/toml v0.3.1 - github.com/aws/aws-sdk-go v1.44.93 + github.com/aws/aws-sdk-go v1.44.94 github.com/fsouza/fake-gcs-server v1.40.1 github.com/gdexlab/go-render v1.0.1 github.com/golang/mock v1.6.0 diff --git a/go.sum b/go.sum index 95e9fb54379..4131efc9430 100644 --- a/go.sum +++ b/go.sum @@ -94,8 +94,8 @@ github.com/antlr/antlr4/runtime/Go/antlr v0.0.0-20220626175859-9abda183db8e h1:b github.com/antlr/antlr4/runtime/Go/antlr v0.0.0-20220626175859-9abda183db8e/go.mod h1:F7bn7fEU90QkQ3tnmaTx3LTKLEDqnwWODIYppRQ5hnY= github.com/armon/go-socks5 v0.0.0-20160902184237-e75332964ef5/go.mod h1:wHh0iHkYZB8zMSxRWpUBQtwG5a7fFgvEO+odwuTv2gs= github.com/asaskevich/govalidator v0.0.0-20190424111038-f61b66f89f4a/go.mod h1:lB+ZfQJz7igIIfQNfa7Ml4HSf2uFQQRzpGGRXenZAgY= -github.com/aws/aws-sdk-go v1.44.93 h1:hAgd9fuaptBatSft27/5eBMdcA8+cIMqo96/tZ6rKl8= -github.com/aws/aws-sdk-go v1.44.93/go.mod h1:y4AeaBuwd2Lk+GepC1E9v0qOiTws0MIWAX4oIKwKHZo= +github.com/aws/aws-sdk-go v1.44.94 h1:hDqJSv03ZVvqT448gUE63JEIHKx++vKLoDkiZxbNmIk= +github.com/aws/aws-sdk-go v1.44.94/go.mod h1:y4AeaBuwd2Lk+GepC1E9v0qOiTws0MIWAX4oIKwKHZo= github.com/blang/semver v3.5.1+incompatible h1:cQNTCjp13qL8KC3Nbxr/y2Bqb63oX6wdnnjpJbkM4JQ= github.com/blang/semver v3.5.1+incompatible/go.mod h1:kRBLl5iJ+tD4TcOOxsy/0fnwebNt5EWlYSAyrTnjyyk= github.com/census-instrumentation/opencensus-proto v0.2.1/go.mod h1:f6KPmirojxKA12rnyqOA5BBL4O983OfeGPqjHWSTneU= From 42abbde451a8566fdca11fe4c2088bc3ecb1c819 Mon Sep 17 00:00:00 2001 From: Thomas Poignant Date: Mon, 26 Sep 2022 17:07:06 +0200 Subject: [PATCH 36/50] Add a validation for the flag to avoid to have invalid flag in the cache Signed-off-by: Thomas Poignant --- feature_flag.go | 2 +- go.sum | 3 +- internal/cache/cache_manager.go | 8 +- internal/cache/cache_manager_test.go | 10 +- internal/cache/in_memory_cache.go | 28 ++- internal/cache/in_memory_cache_test.go | 4 +- internal/flag/internal_flag.go | 34 ++++ internal/flag/internal_flag_test.go | 245 +++++++++++++++++++++++++ internal/flag/rule.go | 37 ++++ 9 files changed, 351 insertions(+), 20 deletions(-) diff --git a/feature_flag.go b/feature_flag.go index 077d1a1c827..910fd4b45b4 100644 --- a/feature_flag.go +++ b/feature_flag.go @@ -78,7 +78,7 @@ func New(config Config) (*GoFeatureFlag, error) { notificationService := cache.NewNotificationService(notifiers) goFF.bgUpdater = newBackgroundUpdater(config.PollingInterval) - goFF.cache = cache.New(notificationService) + goFF.cache = cache.New(notificationService, config.Logger) err := retrieveFlagsAndUpdateCache(goFF.config, goFF.cache) if err != nil && !config.StartWithRetrieverError { diff --git a/go.sum b/go.sum index 4131efc9430..9d4d1d287ee 100644 --- a/go.sum +++ b/go.sum @@ -220,9 +220,8 @@ github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/ github.com/google/go-cmp v0.5.5/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.7/go.mod h1:n+brtR0CgQNWTVd5ZUFpTBC8YFBDLK/h/bpaJ8/DtOE= +github.com/google/go-cmp v0.5.8 h1:e6P7q2lk1O+qJJb4BtCQXlK8vWEO8V1ZeuEdJNOqZyg= github.com/google/go-cmp v0.5.8/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY= -github.com/google/go-cmp v0.5.9 h1:O2Tfq5qg4qc4AmwVlvv0oLiVAGB7enBSJ2x2DqQFi38= -github.com/google/go-cmp v0.5.9/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY= github.com/google/gofuzz v1.0.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg= github.com/google/gofuzz v1.1.0 h1:Hsa8mG0dQ46ij8Sl2AYJDUv1oA9/d6Vk+3LG99Oe02g= github.com/google/gofuzz v1.1.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg= diff --git a/internal/cache/cache_manager.go b/internal/cache/cache_manager.go index dda0a7ad115..1a37b6d020c 100644 --- a/internal/cache/cache_manager.go +++ b/internal/cache/cache_manager.go @@ -29,11 +29,13 @@ type cacheManagerImpl struct { mutex sync.RWMutex notificationService Service latestUpdate time.Time + logger *log.Logger } -func New(notificationService Service) Manager { +func New(notificationService Service, logger *log.Logger) Manager { return &cacheManagerImpl{ - inMemoryCache: NewInMemoryCache(), + logger: logger, + inMemoryCache: NewInMemoryCache(logger), mutex: sync.RWMutex{}, notificationService: notificationService, } @@ -55,7 +57,7 @@ func (c *cacheManagerImpl) UpdateCache(loadedFlags []byte, fileFormat string, lo return err } - newCache := NewInMemoryCache() + newCache := NewInMemoryCache(c.logger) newCache.Init(newFlags) newCacheFlags := newCache.All() oldCacheFlags := map[string]flag.Flag{} diff --git a/internal/cache/cache_manager_test.go b/internal/cache/cache_manager_test.go index 237e81526ae..8f4726ec9f8 100644 --- a/internal/cache/cache_manager_test.go +++ b/internal/cache/cache_manager_test.go @@ -14,14 +14,14 @@ import ( ) func Test_FlagCacheNotInit(t *testing.T) { - fCache := cache.New(nil) + fCache := cache.New(nil, nil) fCache.Close() _, err := fCache.GetFlag("test-flag") assert.Error(t, err, "We should have an error if the cache is not init") } func Test_GetFlagNotExist(t *testing.T) { - fCache := cache.New(nil) + fCache := cache.New(nil, nil) _, err := fCache.GetFlag("not-exists-flag") assert.Error(t, err, "We should have an error if the flag does not exists") } @@ -208,7 +208,7 @@ func Test_FlagCache(t *testing.T) { for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { - fCache := cache.New(cache.NewNotificationService([]notifier.Notifier{})) + fCache := cache.New(cache.NewNotificationService([]notifier.Notifier{}), nil) err := fCache.UpdateCache(tt.args.loadedFlags, tt.flagFormat, log.New(os.Stdout, "", 0)) if tt.wantErr { assert.Error(t, err, "UpdateCache() error = %v, wantErr %v", err, tt.wantErr) @@ -358,7 +358,7 @@ test-flag2: for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { - fCache := cache.New(cache.NewNotificationService([]notifier.Notifier{})) + fCache := cache.New(cache.NewNotificationService([]notifier.Notifier{}), nil) _ = fCache.UpdateCache(tt.args.loadedFlags, tt.flagFormat, log.New(os.Stdout, "", 0)) allFlags, err := fCache.AllFlags() @@ -388,7 +388,7 @@ func Test_cacheManagerImpl_GetLatestUpdateDate(t *testing.T) { trackEvents: false `) - fCache := cache.New(cache.NewNotificationService([]notifier.Notifier{})) + fCache := cache.New(cache.NewNotificationService([]notifier.Notifier{}), nil) timeBefore := fCache.GetLatestUpdateDate() _ = fCache.UpdateCache(loadedFlags, "yaml", log.New(os.Stdout, "", 0)) timeAfter := fCache.GetLatestUpdateDate() diff --git a/internal/cache/in_memory_cache.go b/internal/cache/in_memory_cache.go index a53d29d98e3..6bf4bdf3cbe 100644 --- a/internal/cache/in_memory_cache.go +++ b/internal/cache/in_memory_cache.go @@ -2,6 +2,9 @@ package cache import ( "fmt" + "log" + + "github.com/thomaspoignant/go-feature-flag/internal/fflog" "github.com/thomaspoignant/go-feature-flag/internal/dto" @@ -9,17 +12,23 @@ import ( ) type InMemoryCache struct { - Flags map[string]flag.InternalFlag + Flags map[string]flag.InternalFlag + Logger *log.Logger } -func NewInMemoryCache() *InMemoryCache { +func NewInMemoryCache(logger *log.Logger) *InMemoryCache { return &InMemoryCache{ - Flags: map[string]flag.InternalFlag{}, + Flags: map[string]flag.InternalFlag{}, + Logger: logger, } } func (fc *InMemoryCache) addFlag(key string, value flag.InternalFlag) { - fc.Flags[key] = value + if err := value.IsValid(); err == nil { + fc.Flags[key] = value + } else { + fflog.Printf(fc.Logger, "error: [cache] invalid configuration for flag %s: %s", key, err) + } } func (fc *InMemoryCache) getFlag(key string) (flag.Flag, error) { @@ -39,7 +48,7 @@ func (fc *InMemoryCache) keys() []string { } func (fc *InMemoryCache) Copy() Cache { - inMemoryCache := NewInMemoryCache() + inMemoryCache := NewInMemoryCache(fc.Logger) for k, v := range fc.Flags { inMemoryCache.addFlag(k, v) } @@ -57,8 +66,13 @@ func (fc *InMemoryCache) All() map[string]flag.Flag { func (fc *InMemoryCache) Init(flags map[string]dto.DTO) { cache := make(map[string]flag.InternalFlag, 0) - for k, v := range flags { - cache[k] = v.Convert() + for key, flagDto := range flags { + flagToAdd := flagDto.Convert() + if err := flagToAdd.IsValid(); err == nil { + cache[key] = flagDto.Convert() + } else { + fflog.Printf(fc.Logger, "error: [cache] invalid configuration for flag %s: %s", key, err) + } } fc.Flags = cache } diff --git a/internal/cache/in_memory_cache_test.go b/internal/cache/in_memory_cache_test.go index b39bf45fed6..6bbe9e626d3 100644 --- a/internal/cache/in_memory_cache_test.go +++ b/internal/cache/in_memory_cache_test.go @@ -104,7 +104,7 @@ func TestAll(t *testing.T) { } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { - c := cache.NewInMemoryCache() + c := cache.NewInMemoryCache(nil) c.Init(tt.param) assert.Equal(t, tt.want, c.All()) }) @@ -132,7 +132,7 @@ func TestCopy(t *testing.T) { } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { - c := cache.NewInMemoryCache() + c := cache.NewInMemoryCache(nil) c.Init(tt.param) got := c.Copy() assert.Equal(t, c, got) diff --git a/internal/flag/internal_flag.go b/internal/flag/internal_flag.go index d88d7808f2e..7a66f108eca 100644 --- a/internal/flag/internal_flag.go +++ b/internal/flag/internal_flag.go @@ -169,6 +169,40 @@ func (f *InternalFlag) isExperimentationOver() bool { (f.Rollout.Experimentation.End != nil && now.After(*f.Rollout.Experimentation.End))) } +// IsValid is checking if the current flag is valid. +func (f *InternalFlag) IsValid() error { + if len(f.GetVariations()) == 0 { + return fmt.Errorf("no variation available") + } + + // Validate that we have a default Rule + if f.GetDefaultRule() == nil { + return fmt.Errorf("missing default rule") + } + + const isDefaultRule = true + // Validate rules + if err := f.GetDefaultRule().IsValid(isDefaultRule); err != nil { + return err + } + + ruleNames := map[string]interface{}{} + for _, rule := range f.GetRules() { + if err := rule.IsValid(!isDefaultRule); err != nil { + return err + } + + // Check if we have duplicated rule name + if _, ok := ruleNames[rule.GetName()]; ok && rule.GetName() != "" { + return fmt.Errorf("duplicated rule name: %s", rule.GetName()) + } else if rule.GetName() != "" { + ruleNames[rule.GetName()] = nil + } + } + + return nil +} + // GetVariations is the getter of the field Variations func (f *InternalFlag) GetVariations() map[string]*interface{} { if f.Variations == nil { diff --git a/internal/flag/internal_flag_test.go b/internal/flag/internal_flag_test.go index 834a4cf4569..58a94b78b46 100644 --- a/internal/flag/internal_flag_test.go +++ b/internal/flag/internal_flag_test.go @@ -1,6 +1,7 @@ package flag_test import ( + "fmt" "testing" "time" @@ -1123,3 +1124,247 @@ func TestInternalFlag_GetVariationValue(t *testing.T) { }) } } + +func TestInternalFlag_IsValid(t *testing.T) { + type fields struct { + Variations *map[string]*interface{} + Rules *[]flag.Rule + DefaultRule *flag.Rule + Rollout *flag.Rollout + TrackEvents *bool + Disable *bool + Version *string + } + tests := []struct { + name string + fields fields + wantErr assert.ErrorAssertionFunc + errorMsg string + }{ + { + name: "no variation", + fields: fields{ + Variations: &map[string]*interface{}{}, + }, + wantErr: assert.Error, + errorMsg: "no variation available", + }, + { + name: "no default rule", + fields: fields{ + Variations: &map[string]*interface{}{ + "A": testconvert.Interface("A"), + }, + Rules: &[]flag.Rule{ + { + Name: testconvert.String("Rule1"), + Query: testconvert.String("key eq 1"), + VariationResult: testconvert.String("A"), + }, + }, + }, + errorMsg: "missing default rule", + wantErr: assert.Error, + }, + { + name: "multiple rule with same name", + fields: fields{ + Variations: &map[string]*interface{}{ + "A": testconvert.Interface("A"), + }, + DefaultRule: &flag.Rule{ + VariationResult: testconvert.String("A"), + }, + Rules: &[]flag.Rule{ + { + Name: testconvert.String("Rule1"), + Query: testconvert.String("key eq 1"), + VariationResult: testconvert.String("A"), + }, + { + Name: testconvert.String(""), + Query: testconvert.String("key eq 3"), + VariationResult: testconvert.String("A"), + }, + { + Name: testconvert.String("Rule2"), + Query: testconvert.String("key eq 2"), + VariationResult: testconvert.String("A"), + }, + { + Name: testconvert.String(""), + Query: testconvert.String("key eq 3"), + VariationResult: testconvert.String("A"), + }, + { + Name: testconvert.String("Rule1"), + Query: testconvert.String("key eq 4"), + VariationResult: testconvert.String("A"), + }, + { + Name: testconvert.String(""), + Query: testconvert.String("key eq 5"), + VariationResult: testconvert.String("A"), + }, + }, + }, + errorMsg: "duplicated rule name: Rule1", + wantErr: assert.Error, + }, + { + name: "wrong percentages for default rule", + fields: fields{ + Variations: &map[string]*interface{}{ + "A": testconvert.Interface("A"), + "B": testconvert.Interface("B"), + }, + DefaultRule: &flag.Rule{ + Percentages: &map[string]float64{ + "A": 90, + "B": 20, + }, + }, + }, + errorMsg: "invalid percentages", + wantErr: assert.Error, + }, + { + name: "wrong percentages for targeting", + fields: fields{ + Variations: &map[string]*interface{}{ + "A": testconvert.Interface("A"), + }, + DefaultRule: &flag.Rule{ + Percentages: &map[string]float64{ + "A": 90, + "B": 10, + }, + }, + Rules: &[]flag.Rule{ + { + Name: testconvert.String("Rule1"), + Query: testconvert.String("key eq 5"), + Percentages: &map[string]float64{ + "A": 90, + "B": 20, + }, + }, + }, + }, + errorMsg: "invalid percentages", + wantErr: assert.Error, + }, + { + name: "targeting without query", + fields: fields{ + Variations: &map[string]*interface{}{ + "A": testconvert.Interface("A"), + }, + DefaultRule: &flag.Rule{ + Percentages: &map[string]float64{ + "A": 90, + "B": 10, + }, + }, + Rules: &[]flag.Rule{ + { + Name: testconvert.String("Rule1"), + Percentages: &map[string]float64{ + "A": 90, + "B": 10, + }, + }, + }, + }, + errorMsg: "each targeting should have a query", + wantErr: assert.Error, + }, + { + name: "Nothing to return in rule", + fields: fields{ + Variations: &map[string]*interface{}{ + "A": testconvert.Interface("A"), + "B": testconvert.Interface("B"), + }, + DefaultRule: &flag.Rule{ + Name: testconvert.String("nothing to return"), + }, + }, + errorMsg: "impossible to return value", + wantErr: assert.Error, + }, + { + name: "progressive rollout percentage initial > end", + fields: fields{ + Variations: &map[string]*interface{}{ + "A": testconvert.Interface("A"), + "B": testconvert.Interface("B"), + }, + DefaultRule: &flag.Rule{ + Name: testconvert.String("nothing to return"), + ProgressiveRollout: &flag.ProgressiveRollout{ + Initial: &flag.ProgressiveRolloutStep{ + Variation: testconvert.String("A"), + Percentage: testconvert.Float64(30), + Date: testconvert.Time(time.Now().Add(-2 * time.Second)), + }, + End: &flag.ProgressiveRolloutStep{ + Variation: testconvert.String("A"), + Percentage: testconvert.Float64(20), + Date: testconvert.Time(time.Now().Add(2 * time.Second)), + }, + }, + }, + }, + errorMsg: "invalid progressive rollout, initial percentage should be lower than end percentage: 30/20", + wantErr: assert.Error, + }, + { + name: "ignore invalid rule if disabled", + fields: fields{ + Variations: &map[string]*interface{}{ + "A": testconvert.Interface("A"), + "B": testconvert.Interface("B"), + }, + Rules: &[]flag.Rule{ + { + Name: testconvert.String("Rule1"), + Query: testconvert.String("key eq 5"), + Disable: testconvert.Bool(true), + Percentages: &map[string]float64{ + "A": 90, + "B": 20, + }, + }, + }, + DefaultRule: &flag.Rule{ + Name: testconvert.String("nothing to return"), + VariationResult: testconvert.String("A"), + }, + }, + errorMsg: "", + wantErr: assert.NoError, + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + f := &flag.InternalFlag{ + Variations: tt.fields.Variations, + Rules: tt.fields.Rules, + DefaultRule: tt.fields.DefaultRule, + Rollout: tt.fields.Rollout, + TrackEvents: tt.fields.TrackEvents, + Disable: tt.fields.Disable, + Version: tt.fields.Version, + } + err := f.IsValid() + errMsg := "" + if err != nil { + errMsg = err.Error() + } + tt.wantErr(t, err, fmt.Sprintf("IsValid(): %s", err)) + assert.Equal(t, tt.errorMsg, errMsg) + }) + } +} diff --git a/internal/flag/rule.go b/internal/flag/rule.go index f549b330b21..1df6c7829dc 100644 --- a/internal/flag/rule.go +++ b/internal/flag/rule.go @@ -199,6 +199,43 @@ func (r *Rule) MergeRules(updatedRule Rule) { } } +// IsValid is checking if the rule is valid +func (r *Rule) IsValid(defaultRule bool) error { + if !defaultRule && r.IsDisable() { + return nil + } + + if r.Percentages == nil && r.ProgressiveRollout == nil && r.VariationResult == nil { + return fmt.Errorf("impossible to return value") + } + + // targeting without query + if !defaultRule && r.Query == nil { + return fmt.Errorf("each targeting should have a query") + } + + // Validate the percentage of the rule + if r.Percentages != nil { + count := float64(0) + for _, p := range r.GetPercentages() { + count += p + } + + if count != 100 { + return fmt.Errorf("invalid percentages") + } + } + + // Progressive rollout: check that initial is lower than end + if r.ProgressiveRollout != nil && + (r.GetProgressiveRollout().End.getPercentage() < r.GetProgressiveRollout().Initial.getPercentage()) { + return fmt.Errorf("invalid progressive rollout, initial percentage should be lower "+ + "than end percentage: %v/%v", + r.GetProgressiveRollout().Initial.getPercentage(), r.GetProgressiveRollout().End.getPercentage()) + } + return nil +} + func (r *Rule) GetQuery() string { if r.Query == nil { return "" From c72254c230d5917ff00920083737626a268aa862 Mon Sep 17 00:00:00 2001 From: Thomas Poignant Date: Thu, 29 Sep 2022 22:14:26 +0200 Subject: [PATCH 37/50] Move the rollout options to the top level of the flag Signed-off-by: Thomas Poignant --- cmd/migrationcli/converter.go | 21 +- cmd/migrationcli/test.yaml | 21 ++ examples/data_export_file/flags.yaml | 1 + examples/retriever_file/flags.yaml | 4 + internal/dto/convert_v1.go | 32 +- internal/dto/converter_test.go | 48 ++- internal/dto/converter_v0.go | 3 +- internal/dto/dto.go | 10 + internal/dto/dto_rollout.go | 56 ---- internal/dto/dto_rollout_test.go | 270 ---------------- internal/flag/internal_flag.go | 36 ++- internal/flag/internal_flag_test.go | 297 ++++++++---------- notifier/slacknotifier/notifier_test.go | 8 +- ...d_call_webhook_and_have_valid_results.json | 4 +- 14 files changed, 242 insertions(+), 569 deletions(-) create mode 100644 cmd/migrationcli/test.yaml delete mode 100644 internal/dto/dto_rollout_test.go diff --git a/cmd/migrationcli/converter.go b/cmd/migrationcli/converter.go index 179738ff59c..fb4000195a0 100644 --- a/cmd/migrationcli/converter.go +++ b/cmd/migrationcli/converter.go @@ -49,23 +49,20 @@ func (f *FlagConverter) Migrate() error { func (f *FlagConverter) unmarshall(content []byte) (map[string]dto.DTO, error) { var flags map[string]dto.DTO + var err error switch strings.ToLower(f.InputFormat) { case "toml": - err := toml.Unmarshal(content, &flags) - if err != nil { - return nil, err - } + err = toml.Unmarshal(content, &flags) case "json": - err := json.Unmarshal(content, &flags) - if err != nil { - return nil, err - } + err = json.Unmarshal(content, &flags) default: - err := yaml.Unmarshal(content, &flags) - if err != nil { - return nil, err - } + // default unmarshaller is YAML + err = yaml.Unmarshal(content, &flags) } + if err != nil { + return nil, err + } + return flags, nil } diff --git a/cmd/migrationcli/test.yaml b/cmd/migrationcli/test.yaml new file mode 100644 index 00000000000..cec9396b60e --- /dev/null +++ b/cmd/migrationcli/test.yaml @@ -0,0 +1,21 @@ +test-flag: + percentage: 100 + rule: key eq "random-key" + true: true + false: false + default: false + disable: false + trackEvents: true + version: 1 + rollout: + experimentation: + start: 2021-03-20T00:00:00.10-05:00 + end: 2021-03-21T00:00:00.10-05:00 + + test-flag2: + rule: key eq "not-a-key" + percentage: 100 + true: true + false: false + default: false + version: 12 \ No newline at end of file diff --git a/examples/data_export_file/flags.yaml b/examples/data_export_file/flags.yaml index 1c38b296bf5..1061f4ebdb6 100644 --- a/examples/data_export_file/flags.yaml +++ b/examples/data_export_file/flags.yaml @@ -4,6 +4,7 @@ new-admin-access: false: false default: false + flag-only-for-admin: rule: admin eq true percentage: 100 diff --git a/examples/retriever_file/flags.yaml b/examples/retriever_file/flags.yaml index 1c38b296bf5..02f82fa4315 100644 --- a/examples/retriever_file/flags.yaml +++ b/examples/retriever_file/flags.yaml @@ -3,6 +3,10 @@ new-admin-access: true: true false: false default: false + rollout: + experimentation: + start: 2021-03-20T00:00:00.10-05:00 + end: 2021-03-21T00:00:00.10-05:00 flag-only-for-admin: rule: admin eq true diff --git a/internal/dto/convert_v1.go b/internal/dto/convert_v1.go index 6d6bfd8cb96..ced0b2d0c55 100644 --- a/internal/dto/convert_v1.go +++ b/internal/dto/convert_v1.go @@ -4,28 +4,22 @@ import "github.com/thomaspoignant/go-feature-flag/internal/flag" // ConvertV1DtoToInternalFlag is converting a DTO to a flag.InternalFlag func ConvertV1DtoToInternalFlag(dto DTO) flag.InternalFlag { - var rollout *flag.Rollout - if dto.Rollout != nil { - rollout = &flag.Rollout{} - if dto.Rollout.V1Rollout.Scheduled != nil { - rollout.Scheduled = dto.Rollout.V1Rollout.Scheduled - } - - if dto.Rollout.Experimentation != nil { - rollout.Experimentation = &flag.ExperimentationRollout{ - Start: dto.Rollout.Experimentation.Start, - End: dto.Rollout.Experimentation.End, - } + var experimentation *flag.ExperimentationRollout + if dto.Experimentation != nil { + experimentation = &flag.ExperimentationRollout{ + Start: dto.Experimentation.Start, + End: dto.Experimentation.End, } } return flag.InternalFlag{ - Variations: dto.Variations, - Rules: dto.Rules, - DefaultRule: dto.DefaultRule, - Rollout: rollout, - TrackEvents: dto.TrackEvents, - Disable: dto.Disable, - Version: dto.Version, + Variations: dto.Variations, + Rules: dto.Rules, + DefaultRule: dto.DefaultRule, + TrackEvents: dto.TrackEvents, + Disable: dto.Disable, + Version: dto.Version, + Scheduled: dto.Scheduled, + Experimentation: experimentation, } } diff --git a/internal/dto/converter_test.go b/internal/dto/converter_test.go index 41d97a665d3..23756c05aa2 100644 --- a/internal/dto/converter_test.go +++ b/internal/dto/converter_test.go @@ -4,6 +4,8 @@ import ( "testing" "time" + "github.com/google/go-cmp/cmp" + "github.com/thomaspoignant/go-feature-flag/ffuser" "github.com/thomaspoignant/go-feature-flag/testutils/flagv1" @@ -223,11 +225,9 @@ func TestConvertV0DtoToInternalFlag(t *testing.T) { Name: testconvert.String("legacyDefaultRule"), VariationResult: testconvert.String("Default"), }, - Rollout: &flag.Rollout{ - Experimentation: &flag.ExperimentationRollout{ - Start: testconvert.Time(time.Date(2021, time.February, 1, 10, 10, 10, 10, time.UTC)), - End: testconvert.Time(time.Date(2021, time.February, 2, 10, 10, 10, 10, time.UTC)), - }, + Experimentation: &flag.ExperimentationRollout{ + Start: testconvert.Time(time.Date(2021, time.February, 1, 10, 10, 10, 10, time.UTC)), + End: testconvert.Time(time.Date(2021, time.February, 2, 10, 10, 10, 10, time.UTC)), }, }, }, @@ -370,15 +370,11 @@ func TestConvertV0DtoToInternalFlag(t *testing.T) { DefaultRule: &flag.Rule{ VariationResult: testconvert.String("VariationDefault"), }, - }, - Rollout: &dto.Rollout{ - CommonRollout: dto.CommonRollout{ - Experimentation: &dto.ExperimentationDto{ - Start: testconvert.Time(time.Date(2021, time.February, 1, 10, 10, 10, 10, time.UTC)), - End: testconvert.Time(time.Date(2021, time.February, 2, 10, 10, 10, 10, time.UTC)), - }, + Experimentation: &dto.ExperimentationDto{ + Start: testconvert.Time(time.Date(2021, time.February, 1, 10, 10, 10, 10, time.UTC)), + End: testconvert.Time(time.Date(2021, time.February, 2, 10, 10, 10, 10, time.UTC)), }, - V1Rollout: dto.V1Rollout{Scheduled: &[]flag.ScheduledStep{ + Scheduled: &[]flag.ScheduledStep{ { InternalFlag: flag.InternalFlag{ Variations: &map[string]*interface{}{ @@ -387,7 +383,7 @@ func TestConvertV0DtoToInternalFlag(t *testing.T) { }, Date: testconvert.Time(time.Date(2021, time.February, 2, 10, 10, 10, 10, time.UTC)), }, - }}, + }, }, }, want: flag.InternalFlag{ @@ -425,20 +421,18 @@ func TestConvertV0DtoToInternalFlag(t *testing.T) { DefaultRule: &flag.Rule{ VariationResult: testconvert.String("VariationDefault"), }, - Rollout: &flag.Rollout{ - Experimentation: &flag.ExperimentationRollout{ - Start: testconvert.Time(time.Date(2021, time.February, 1, 10, 10, 10, 10, time.UTC)), - End: testconvert.Time(time.Date(2021, time.February, 2, 10, 10, 10, 10, time.UTC)), - }, - Scheduled: &[]flag.ScheduledStep{ - { - InternalFlag: flag.InternalFlag{ - Variations: &map[string]*interface{}{ - "VariationDefault": testconvert.Interface(true), - }, + Experimentation: &flag.ExperimentationRollout{ + Start: testconvert.Time(time.Date(2021, time.February, 1, 10, 10, 10, 10, time.UTC)), + End: testconvert.Time(time.Date(2021, time.February, 2, 10, 10, 10, 10, time.UTC)), + }, + Scheduled: &[]flag.ScheduledStep{ + { + InternalFlag: flag.InternalFlag{ + Variations: &map[string]*interface{}{ + "VariationDefault": testconvert.Interface(true), }, - Date: testconvert.Time(time.Date(2021, time.February, 2, 10, 10, 10, 10, time.UTC)), }, + Date: testconvert.Time(time.Date(2021, time.February, 2, 10, 10, 10, 10, time.UTC)), }, }, }, @@ -446,7 +440,7 @@ func TestConvertV0DtoToInternalFlag(t *testing.T) { } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { - assert.Equal(t, tt.want, tt.d.Convert()) + assert.Equal(t, tt.want, tt.d.Convert(), cmp.Diff(tt.want, tt.d.Convert())) }) } } diff --git a/internal/dto/converter_v0.go b/internal/dto/converter_v0.go index 3e881c8a138..36f8418ab51 100644 --- a/internal/dto/converter_v0.go +++ b/internal/dto/converter_v0.go @@ -51,9 +51,10 @@ func ConvertV0DtoToInternalFlag(d DTO, isScheduledStep bool) flag.InternalFlag { var rollout *flag.Rollout if d.Rollout != nil && (d.Rollout.Experimentation != nil || d.Rollout.V0Rollout.Scheduled != nil) { rollout = convertRollout(d, internalFlag) + internalFlag.Scheduled = rollout.Scheduled + internalFlag.Experimentation = rollout.Experimentation } - internalFlag.Rollout = rollout return internalFlag } diff --git a/internal/dto/dto.go b/internal/dto/dto.go index 27da61558bb..4336ecb47fc 100644 --- a/internal/dto/dto.go +++ b/internal/dto/dto.go @@ -44,6 +44,16 @@ type DTOv1 struct { // DefaultRule is the originalRule applied after checking that any other rules // matched the user. DefaultRule *flag.Rule `json:"defaultRule,omitempty" yaml:"defaultRule,omitempty" toml:"defaultRule,omitempty"` + + // Scheduled is your struct to configure an update on some fields of your flag over time. + // You can add several steps that updates the flag, this is typically used if you want to gradually add more user + // in your flag. + Scheduled *[]flag.ScheduledStep `json:"scheduledRollout,omitempty" yaml:"scheduledRollout,omitempty" toml:"scheduledRollout,omitempty"` // nolint: lll + + // Experimentation is your struct to configure an experimentation, it will allow you to configure a start date and + // an end date for your flag. + // When the experimentation is not running, the flag will serve the default value. + Experimentation *ExperimentationDto `json:"experimentation,omitempty" yaml:"experimentation,omitempty" toml:"experimentation,omitempty"` // nolint: lll } // DTOv0 describe the fields of a flag. diff --git a/internal/dto/dto_rollout.go b/internal/dto/dto_rollout.go index b6863976380..1ba36634923 100644 --- a/internal/dto/dto_rollout.go +++ b/internal/dto/dto_rollout.go @@ -1,10 +1,7 @@ package dto import ( - "encoding/json" "time" - - "github.com/thomaspoignant/go-feature-flag/internal/flag" ) type ExperimentationDto struct { @@ -20,9 +17,6 @@ type Rollout struct { // all types of flag in your input file. CommonRollout `json:",inline" yaml:",inline" toml:",inline"` - // V1Rollout contains the configuration available only for the flags version v1.X.X - V1Rollout `json:",inline" yaml:",inline" toml:",inline"` - // V0Rollout contains the configuration available only for the flags version v0.X.X V0Rollout `json:",inline" yaml:",inline" toml:",inline"` // nolint: govet } @@ -40,13 +34,6 @@ type CommonRollout struct { Progressive *ProgressiveV0 `json:"progressive,omitempty" yaml:"progressive,omitempty" toml:"progressive,omitempty"` // nolint: lll } -type V1Rollout struct { - // Scheduled is your struct to configure an update on some fields of your flag over time. - // You can add several steps that updates the flag, this is typically used if you want to gradually add more user - // in your flag. - Scheduled *[]flag.ScheduledStep `json:"scheduled,omitempty" yaml:"scheduled,omitempty" toml:"scheduled,omitempty"` // nolint: lll -} - type V0Rollout struct { // Scheduled is your struct to configure an update on some fields of your flag over time. // You can add several steps that updates the flag, this is typically used if you want to gradually add more user @@ -54,49 +41,6 @@ type V0Rollout struct { Scheduled *ScheduledRolloutV0 `json:"scheduled,omitempty" yaml:"scheduled,omitempty" toml:"scheduled,omitempty"` // nolint: lll } -// UnmarshalJSON is dealing with the fact that we have 2 different entry called scheduled -// in different format, this can cause an issue when unmarshalling the data. -// This is the reason why we have a custom unmarshalling function for this struct. -func (p *Rollout) UnmarshalJSON(data []byte) error { - var c CommonRollout - err := json.Unmarshal(data, &c) - if err != nil { - return err - } - p.CommonRollout = c - - var v1 V1Rollout - // we ignore the unmarshal errors because they are expected since we have multiple format - _ = json.Unmarshal(data, &v1) - // if err != nil { - // // TODO: add log in debug only - //} - if v1.Scheduled != nil && *v1.Scheduled != nil { - p.V1Rollout = v1 - } - - var v0 V0Rollout - // we ignore the unmarshal errors because they are expected since we have multiple format - _ = json.Unmarshal(data, &v0) - // if err != nil { - // // TODO: add log in debug only - //} - p.V0Rollout = v0 - - return nil -} - -// UnmarshalTOML is used for TOML unmarshalling, the lib is not calling directly UnmarshalJSON, -// so we are calling it after marshaling input in JSON string -func (p *Rollout) UnmarshalTOML(input interface{}) error { - jsonStr, err := json.Marshal(input) - if err != nil { - // TODO: add log in debug only - return err - } - return p.UnmarshalJSON(jsonStr) -} - type ScheduledRolloutV0 struct { // Steps is the list of updates to do in a specific date. Steps []ScheduledStepV0 `json:"steps,omitempty" yaml:"steps,omitempty" toml:"steps,omitempty"` diff --git a/internal/dto/dto_rollout_test.go b/internal/dto/dto_rollout_test.go deleted file mode 100644 index 9bb8445bba9..00000000000 --- a/internal/dto/dto_rollout_test.go +++ /dev/null @@ -1,270 +0,0 @@ -package dto_test - -import ( - "encoding/json" - "os" - "strings" - "testing" - "time" - - "github.com/google/go-cmp/cmp" - - "github.com/BurntSushi/toml" - - "github.com/thomaspoignant/go-feature-flag/internal/flag" - - "github.com/thomaspoignant/go-feature-flag/testutils/testconvert" - - "github.com/thomaspoignant/go-feature-flag/internal/dto" - "k8s.io/apimachinery/pkg/util/yaml" - - "github.com/stretchr/testify/assert" -) - -func TestRollout_UnmarshalJSON(t *testing.T) { - tests := []struct { - name string - input string - fileType string - want dto.Rollout - wantErr assert.ErrorAssertionFunc - }{ - { - name: "Should unmarshal valid JSON file", - input: "../../testdata/internal/dto/rollout.json", - fileType: "json", - want: dto.Rollout{ - V1Rollout: dto.V1Rollout{ - Scheduled: &[]flag.ScheduledStep{ - { - Date: testconvert.Time(time.Date(2021, time.February, 1, 10, 10, 10, 10, time.UTC)), - InternalFlag: flag.InternalFlag{ - Variations: &map[string]*interface{}{ - "VariationDefault": testconvert.Interface(true), - }, - }, - }, - { - Date: testconvert.Time(time.Date(2021, time.February, 2, 10, 10, 10, 10, time.UTC)), - InternalFlag: flag.InternalFlag{ - Variations: &map[string]*interface{}{ - "VariationDefault": testconvert.Interface(false), - }, - }, - }, - }, - }, - V0Rollout: dto.V0Rollout{Scheduled: &dto.ScheduledRolloutV0{}}, - CommonRollout: dto.CommonRollout{ - Experimentation: &dto.ExperimentationDto{ - Start: testconvert.Time(time.Date(2021, time.February, 1, 10, 10, 10, 10, time.UTC)), - End: testconvert.Time(time.Date(2021, time.March, 1, 10, 10, 10, 10, time.UTC)), - }, - Progressive: nil, - }, - }, - wantErr: assert.NoError, - }, - { - name: "Should unmarshal valid TOML file", - input: "../../testdata/internal/dto/rollout.toml", - fileType: "toml", - want: dto.Rollout{ - V1Rollout: dto.V1Rollout{ - Scheduled: &[]flag.ScheduledStep{ - { - Date: testconvert.Time(time.Date(2021, time.February, 1, 10, 10, 10, 10, time.UTC)), - InternalFlag: flag.InternalFlag{ - Variations: &map[string]*interface{}{ - "VariationDefault": testconvert.Interface(true), - }, - }, - }, - { - Date: testconvert.Time(time.Date(2021, time.February, 2, 10, 10, 10, 10, time.UTC)), - InternalFlag: flag.InternalFlag{ - Variations: &map[string]*interface{}{ - "VariationDefault": testconvert.Interface(false), - }, - }, - }, - }, - }, - V0Rollout: dto.V0Rollout{Scheduled: &dto.ScheduledRolloutV0{}}, - CommonRollout: dto.CommonRollout{ - Experimentation: &dto.ExperimentationDto{ - Start: testconvert.Time(time.Date(2021, time.February, 1, 10, 10, 10, 10, time.UTC)), - End: testconvert.Time(time.Date(2021, time.March, 1, 10, 10, 10, 10, time.UTC)), - }, - Progressive: nil, - }, - }, - wantErr: assert.NoError, - }, - { - name: "Should unmarshal valid YAML file", - input: "../../testdata/internal/dto/rollout.yaml", - fileType: "yaml", - want: dto.Rollout{ - V1Rollout: dto.V1Rollout{ - Scheduled: &[]flag.ScheduledStep{ - { - Date: testconvert.Time(time.Date(2021, time.February, 1, 10, 10, 10, 10, time.UTC)), - InternalFlag: flag.InternalFlag{ - Variations: &map[string]*interface{}{ - "VariationDefault": testconvert.Interface(true), - }, - }, - }, - { - Date: testconvert.Time(time.Date(2021, time.February, 2, 10, 10, 10, 10, time.UTC)), - InternalFlag: flag.InternalFlag{ - Variations: &map[string]*interface{}{ - "VariationDefault": testconvert.Interface(false), - }, - }, - }, - }, - }, - V0Rollout: dto.V0Rollout{Scheduled: &dto.ScheduledRolloutV0{}}, - CommonRollout: dto.CommonRollout{ - Experimentation: &dto.ExperimentationDto{ - Start: testconvert.Time(time.Date(2021, time.February, 1, 10, 10, 10, 10, time.UTC)), - End: testconvert.Time(time.Date(2021, time.March, 1, 10, 10, 10, 10, time.UTC)), - }, - Progressive: nil, - }, - }, - wantErr: assert.NoError, - }, - { - name: "Should unmarshal valid JSON file with v0 rollout", - input: "../../testdata/internal/dto/rollout_v0.json", - fileType: "JSON", - want: dto.Rollout{ - V0Rollout: dto.V0Rollout{Scheduled: &dto.ScheduledRolloutV0{ - Steps: []dto.ScheduledStepV0{ - { - DTO: dto.DTO{ - DTOv0: dto.DTOv0{ - Rule: testconvert.String("beta eq \"true\""), - Percentage: testconvert.Float64(100), - }, - }, - Date: testconvert.Time(time.Date(2021, time.February, 2, 10, 10, 10, 10, time.UTC)), - }, - { - DTO: dto.DTO{ - DTOv0: dto.DTOv0{ - Rule: testconvert.String("beta eq \"false\""), - }, - }, - Date: testconvert.Time(time.Date(2021, time.February, 2, 10, 10, 10, 10, time.UTC)), - }, - }, - }}, - CommonRollout: dto.CommonRollout{ - Experimentation: &dto.ExperimentationDto{ - Start: testconvert.Time(time.Date(2021, time.February, 1, 10, 10, 10, 10, time.UTC)), - End: testconvert.Time(time.Date(2021, time.March, 1, 10, 10, 10, 10, time.UTC)), - }, - Progressive: nil, - }, - }, - wantErr: assert.NoError, - }, - { - name: "Should unmarshal valid TOML file with v0 rollout", - input: "../../testdata/internal/dto/rollout_v0.toml", - fileType: "TOML", - want: dto.Rollout{ - V0Rollout: dto.V0Rollout{Scheduled: &dto.ScheduledRolloutV0{ - Steps: []dto.ScheduledStepV0{ - { - DTO: dto.DTO{ - DTOv0: dto.DTOv0{ - Rule: testconvert.String("beta eq \"true\""), - Percentage: testconvert.Float64(100), - }, - }, - Date: testconvert.Time(time.Date(2021, time.February, 2, 10, 10, 10, 10, time.UTC)), - }, - { - DTO: dto.DTO{ - DTOv0: dto.DTOv0{ - Rule: testconvert.String("beta eq \"false\""), - }, - }, - Date: testconvert.Time(time.Date(2021, time.February, 2, 10, 10, 10, 10, time.UTC)), - }, - }, - }}, - CommonRollout: dto.CommonRollout{ - Experimentation: &dto.ExperimentationDto{ - Start: testconvert.Time(time.Date(2021, time.February, 1, 10, 10, 10, 10, time.UTC)), - End: testconvert.Time(time.Date(2021, time.March, 1, 10, 10, 10, 10, time.UTC)), - }, - Progressive: nil, - }, - }, - wantErr: assert.NoError, - }, - { - name: "Should unmarshal valid YAML file with v0 rollout", - input: "../../testdata/internal/dto/rollout_v0.yaml", - fileType: "YAML", - want: dto.Rollout{ - V0Rollout: dto.V0Rollout{Scheduled: &dto.ScheduledRolloutV0{ - Steps: []dto.ScheduledStepV0{ - { - DTO: dto.DTO{ - DTOv0: dto.DTOv0{ - Rule: testconvert.String("beta eq \"true\""), - Percentage: testconvert.Float64(100), - }, - }, - Date: testconvert.Time(time.Date(2021, time.February, 2, 10, 10, 10, 10, time.UTC)), - }, - { - DTO: dto.DTO{ - DTOv0: dto.DTOv0{ - Rule: testconvert.String("beta eq \"false\""), - }, - }, - Date: testconvert.Time(time.Date(2021, time.February, 2, 10, 10, 10, 10, time.UTC)), - }, - }, - }}, - CommonRollout: dto.CommonRollout{ - Experimentation: &dto.ExperimentationDto{ - Start: testconvert.Time(time.Date(2021, time.February, 1, 10, 10, 10, 10, time.UTC)), - End: testconvert.Time(time.Date(2021, time.March, 1, 10, 10, 10, 10, time.UTC)), - }, - Progressive: nil, - }, - }, - wantErr: assert.NoError, - }, - } - for _, tt := range tests { - t.Run(tt.name, func(t *testing.T) { - var err error - var r dto.Rollout - content, err := os.ReadFile(tt.input) - assert.NoError(t, err, "impossible to find input test file %v", tt.input) - - switch strings.ToLower(tt.fileType) { - case "toml": - _, err = toml.Decode(string(content), &r) - case "json": - err = json.Unmarshal(content, &r) - case "yaml": - err = yaml.Unmarshal(content, &r) - default: - panic("not expected") - } - tt.wantErr(t, err) - assert.Equal(t, tt.want, r, cmp.Diff(tt.want, r)) - }) - } -} diff --git a/internal/flag/internal_flag.go b/internal/flag/internal_flag.go index 7a66f108eca..47b19e1c9e4 100644 --- a/internal/flag/internal_flag.go +++ b/internal/flag/internal_flag.go @@ -30,8 +30,15 @@ type InternalFlag struct { // matched the user. DefaultRule *Rule `json:"defaultRule,omitempty" yaml:"defaultRule,omitempty" toml:"defaultRule,omitempty"` - // Rollout is how we roll out the flag - Rollout *Rollout `json:"rollout,omitempty" yaml:"rollout,omitempty" toml:"rollout,omitempty"` + // Experimentation is your struct to configure an experimentation, it will allow you to configure a start date and + // an end date for your flag. + // When the experimentation is not running, the flag will serve the default value. + Experimentation *ExperimentationRollout `json:"experimentation,omitempty" yaml:"experimentation,omitempty" toml:"experimentation,omitempty"` // nolint: lll + + // Scheduled is your struct to configure an update on some fields of your flag over time. + // You can add several steps that updates the flag, this is typically used if you want to gradually add more user + // in your flag. + Scheduled *[]ScheduledStep `json:"scheduledRollout,omitempty" yaml:"scheduledRollout,omitempty" toml:"scheduledRollout,omitempty"` // nolint: lll // TrackEvents is false if you don't want to export the data in your data exporter. // Default value is true @@ -118,8 +125,8 @@ func (f *InternalFlag) selectVariation(flagName string, user ffuser.User) (*vari // If yes we merge the changes to the current flag. func (f *InternalFlag) applyScheduledRolloutSteps() { evaluationDate := time.Now() - if f.Rollout != nil && f.Rollout.Scheduled != nil { - for _, steps := range *f.Rollout.Scheduled { + if f.Scheduled != nil { + for _, steps := range *f.Scheduled { if steps.Date != nil && steps.Date.Before(evaluationDate) { f.Rules = MergeSetOfRules(f.GetRules(), steps.GetRules()) if steps.Disable != nil { @@ -144,15 +151,15 @@ func (f *InternalFlag) applyScheduledRolloutSteps() { f.Version = steps.Version } - if steps.Rollout != nil && steps.Rollout.Experimentation != nil { - if f.Rollout.Experimentation == nil { - f.Rollout.Experimentation = &ExperimentationRollout{} + if steps.Experimentation != nil { + if f.Experimentation == nil { + f.Experimentation = &ExperimentationRollout{} } - if steps.Rollout.Experimentation.Start != nil { - f.Rollout.Experimentation.End = steps.Rollout.Experimentation.End + if steps.Experimentation.Start != nil { + f.Experimentation.End = steps.Experimentation.End } - if steps.Rollout.Experimentation.End != nil { - f.Rollout.Experimentation.End = steps.Rollout.Experimentation.End + if steps.Experimentation.End != nil { + f.Experimentation.End = steps.Experimentation.End } } } @@ -163,10 +170,9 @@ func (f *InternalFlag) applyScheduledRolloutSteps() { // isExperimentationOver checks if we are in an experimentation or not func (f *InternalFlag) isExperimentationOver() bool { now := time.Now() - return f.Rollout != nil && - f.Rollout.Experimentation != nil && - ((f.Rollout.Experimentation.Start != nil && now.Before(*f.Rollout.Experimentation.Start)) || - (f.Rollout.Experimentation.End != nil && now.After(*f.Rollout.Experimentation.End))) + return f.Experimentation != nil && + ((f.Experimentation.Start != nil && now.Before(*f.Experimentation.Start)) || + (f.Experimentation.End != nil && now.After(*f.Experimentation.End))) } // IsValid is checking if the current flag is valid. diff --git a/internal/flag/internal_flag_test.go b/internal/flag/internal_flag_test.go index 58a94b78b46..7a68cac43a9 100644 --- a/internal/flag/internal_flag_test.go +++ b/internal/flag/internal_flag_test.go @@ -95,11 +95,9 @@ func TestInternalFlag_Value(t *testing.T) { { name: "Should return sdk default value when experimentation rollout not started", flag: flag.InternalFlag{ - Rollout: &flag.Rollout{ - Experimentation: &flag.ExperimentationRollout{ - Start: testconvert.Time(time.Now().Add(1 * time.Second)), - End: testconvert.Time(time.Now().Add(5 * time.Second)), - }, + Experimentation: &flag.ExperimentationRollout{ + Start: testconvert.Time(time.Now().Add(1 * time.Second)), + End: testconvert.Time(time.Now().Add(5 * time.Second)), }, }, args: args{ @@ -118,11 +116,9 @@ func TestInternalFlag_Value(t *testing.T) { { name: "Should return sdk default value when experimentation rollout ended", flag: flag.InternalFlag{ - Rollout: &flag.Rollout{ - Experimentation: &flag.ExperimentationRollout{ - Start: testconvert.Time(time.Now().Add(-15 * time.Second)), - End: testconvert.Time(time.Now().Add(-5 * time.Second)), - }, + Experimentation: &flag.ExperimentationRollout{ + Start: testconvert.Time(time.Now().Add(-15 * time.Second)), + End: testconvert.Time(time.Now().Add(-5 * time.Second)), }, }, args: args{ @@ -438,24 +434,22 @@ func TestInternalFlag_Value(t *testing.T) { DefaultRule: &flag.Rule{ VariationResult: testconvert.String("variation_A"), }, - Rollout: &flag.Rollout{ - Scheduled: &[]flag.ScheduledStep{ - { - InternalFlag: flag.InternalFlag{ - DefaultRule: &flag.Rule{ - VariationResult: testconvert.String("variation_B"), - }, + Scheduled: &[]flag.ScheduledStep{ + { + InternalFlag: flag.InternalFlag{ + DefaultRule: &flag.Rule{ + VariationResult: testconvert.String("variation_B"), }, - Date: testconvert.Time(time.Now().Add(1 * time.Second)), }, - { - InternalFlag: flag.InternalFlag{ - Variations: &map[string]*interface{}{ - "variation_A": testconvert.Interface("value_QWERTY"), - }, + Date: testconvert.Time(time.Now().Add(1 * time.Second)), + }, + { + InternalFlag: flag.InternalFlag{ + Variations: &map[string]*interface{}{ + "variation_A": testconvert.Interface("value_QWERTY"), }, - Date: testconvert.Time(time.Now().Add(2 * time.Second)), }, + Date: testconvert.Time(time.Now().Add(2 * time.Second)), }, }, }, @@ -482,24 +476,22 @@ func TestInternalFlag_Value(t *testing.T) { DefaultRule: &flag.Rule{ VariationResult: testconvert.String("variation_A"), }, - Rollout: &flag.Rollout{ - Scheduled: &[]flag.ScheduledStep{ - { - InternalFlag: flag.InternalFlag{ - DefaultRule: &flag.Rule{ - VariationResult: testconvert.String("variation_B"), - }, + Scheduled: &[]flag.ScheduledStep{ + { + InternalFlag: flag.InternalFlag{ + DefaultRule: &flag.Rule{ + VariationResult: testconvert.String("variation_B"), }, - Date: testconvert.Time(time.Now().Add(-1 * time.Second)), }, - { - InternalFlag: flag.InternalFlag{ - Variations: &map[string]*interface{}{ - "variation_B": testconvert.Interface("value_QWERTY"), - }, + Date: testconvert.Time(time.Now().Add(-1 * time.Second)), + }, + { + InternalFlag: flag.InternalFlag{ + Variations: &map[string]*interface{}{ + "variation_B": testconvert.Interface("value_QWERTY"), }, - Date: testconvert.Time(time.Now().Add(2 * time.Second)), }, + Date: testconvert.Time(time.Now().Add(2 * time.Second)), }, }, }, @@ -526,24 +518,22 @@ func TestInternalFlag_Value(t *testing.T) { DefaultRule: &flag.Rule{ VariationResult: testconvert.String("variation_A"), }, - Rollout: &flag.Rollout{ - Scheduled: &[]flag.ScheduledStep{ - { - InternalFlag: flag.InternalFlag{ - DefaultRule: &flag.Rule{ - VariationResult: testconvert.String("variation_B"), - }, + Scheduled: &[]flag.ScheduledStep{ + { + InternalFlag: flag.InternalFlag{ + DefaultRule: &flag.Rule{ + VariationResult: testconvert.String("variation_B"), }, - Date: testconvert.Time(time.Now().Add(-2 * time.Second)), }, - { - InternalFlag: flag.InternalFlag{ - Variations: &map[string]*interface{}{ - "variation_B": testconvert.Interface("value_QWERTY"), - }, + Date: testconvert.Time(time.Now().Add(-2 * time.Second)), + }, + { + InternalFlag: flag.InternalFlag{ + Variations: &map[string]*interface{}{ + "variation_B": testconvert.Interface("value_QWERTY"), }, - Date: testconvert.Time(time.Now().Add(-1 * time.Second)), }, + Date: testconvert.Time(time.Now().Add(-1 * time.Second)), }, }, }, @@ -570,13 +560,11 @@ func TestInternalFlag_Value(t *testing.T) { DefaultRule: &flag.Rule{ VariationResult: testconvert.String("variation_A"), }, - Rollout: &flag.Rollout{ - Scheduled: &[]flag.ScheduledStep{ - { - InternalFlag: flag.InternalFlag{ - Variations: &map[string]*interface{}{ - "variation_A": testconvert.Interface("value_QWERTY"), - }, + Scheduled: &[]flag.ScheduledStep{ + { + InternalFlag: flag.InternalFlag{ + Variations: &map[string]*interface{}{ + "variation_A": testconvert.Interface("value_QWERTY"), }, }, }, @@ -612,19 +600,17 @@ func TestInternalFlag_Value(t *testing.T) { DefaultRule: &flag.Rule{ VariationResult: testconvert.String("variation_A"), }, - Rollout: &flag.Rollout{ - Scheduled: &[]flag.ScheduledStep{ - { - Date: testconvert.Time(time.Now().Add(-1 * time.Second)), - InternalFlag: flag.InternalFlag{ - Variations: &map[string]*interface{}{ - "variation_C": testconvert.Interface("value_C"), - }, - Rules: &[]flag.Rule{ - { - Name: testconvert.String("rule1"), - VariationResult: testconvert.String("variation_C"), - }, + Scheduled: &[]flag.ScheduledStep{ + { + Date: testconvert.Time(time.Now().Add(-1 * time.Second)), + InternalFlag: flag.InternalFlag{ + Variations: &map[string]*interface{}{ + "variation_C": testconvert.Interface("value_C"), + }, + Rules: &[]flag.Rule{ + { + Name: testconvert.String("rule1"), + VariationResult: testconvert.String("variation_C"), }, }, }, @@ -660,16 +646,14 @@ func TestInternalFlag_Value(t *testing.T) { "variation_B": 90, }, }, - Rollout: &flag.Rollout{ - Scheduled: &[]flag.ScheduledStep{ - { - Date: testconvert.Time(time.Now().Add(-2 * time.Second)), - InternalFlag: flag.InternalFlag{ - DefaultRule: &flag.Rule{ - Percentages: &map[string]float64{ - "variation_B": 20, - "variation_C": 70, - }, + Scheduled: &[]flag.ScheduledStep{ + { + Date: testconvert.Time(time.Now().Add(-2 * time.Second)), + InternalFlag: flag.InternalFlag{ + DefaultRule: &flag.Rule{ + Percentages: &map[string]float64{ + "variation_B": 20, + "variation_C": 70, }, }, }, @@ -706,20 +690,18 @@ func TestInternalFlag_Value(t *testing.T) { DefaultRule: &flag.Rule{ VariationResult: testconvert.String("variation_A"), }, - Rollout: &flag.Rollout{ - Scheduled: &[]flag.ScheduledStep{ - { - Date: testconvert.Time(time.Now().Add(-1 * time.Second)), - InternalFlag: flag.InternalFlag{ - Variations: &map[string]*interface{}{ - "variation_C": testconvert.Interface("value_C"), - }, - Rules: &[]flag.Rule{ - { - Name: testconvert.String("rule2"), - Query: testconvert.String("key eq \"user-key-123\""), - VariationResult: testconvert.String("variation_C"), - }, + Scheduled: &[]flag.ScheduledStep{ + { + Date: testconvert.Time(time.Now().Add(-1 * time.Second)), + InternalFlag: flag.InternalFlag{ + Variations: &map[string]*interface{}{ + "variation_C": testconvert.Interface("value_C"), + }, + Rules: &[]flag.Rule{ + { + Name: testconvert.String("rule2"), + Query: testconvert.String("key eq \"user-key-123\""), + VariationResult: testconvert.String("variation_C"), }, }, }, @@ -751,24 +733,22 @@ func TestInternalFlag_Value(t *testing.T) { DefaultRule: &flag.Rule{ VariationResult: testconvert.String("variation_A"), }, - Rollout: &flag.Rollout{ - Scheduled: &[]flag.ScheduledStep{ - { - InternalFlag: flag.InternalFlag{ - DefaultRule: &flag.Rule{ - VariationResult: testconvert.String("variation_B"), - }, + Scheduled: &[]flag.ScheduledStep{ + { + InternalFlag: flag.InternalFlag{ + DefaultRule: &flag.Rule{ + VariationResult: testconvert.String("variation_B"), }, - Date: testconvert.Time(time.Now().Add(-2 * time.Second)), }, - { - InternalFlag: flag.InternalFlag{ - Variations: &map[string]*interface{}{ - "variation_B": testconvert.Interface("value_QWERTY"), - }, + Date: testconvert.Time(time.Now().Add(-2 * time.Second)), + }, + { + InternalFlag: flag.InternalFlag{ + Variations: &map[string]*interface{}{ + "variation_B": testconvert.Interface("value_QWERTY"), }, - Date: testconvert.Time(time.Now().Add(-1 * time.Second)), }, + Date: testconvert.Time(time.Now().Add(-1 * time.Second)), }, }, }, @@ -795,16 +775,14 @@ func TestInternalFlag_Value(t *testing.T) { DefaultRule: &flag.Rule{ VariationResult: testconvert.String("variation_A"), }, - Rollout: &flag.Rollout{ - Scheduled: &[]flag.ScheduledStep{ - { - InternalFlag: flag.InternalFlag{ - Disable: testconvert.Bool(true), - TrackEvents: testconvert.Bool(false), - Version: testconvert.String("1.0.0"), - }, - Date: testconvert.Time(time.Now().Add(-2 * time.Second)), + Scheduled: &[]flag.ScheduledStep{ + { + InternalFlag: flag.InternalFlag{ + Disable: testconvert.Bool(true), + TrackEvents: testconvert.Bool(false), + Version: testconvert.String("1.0.0"), }, + Date: testconvert.Time(time.Now().Add(-2 * time.Second)), }, }, }, @@ -831,19 +809,15 @@ func TestInternalFlag_Value(t *testing.T) { DefaultRule: &flag.Rule{ VariationResult: testconvert.String("variation_A"), }, - Rollout: &flag.Rollout{ - Scheduled: &[]flag.ScheduledStep{ - { - InternalFlag: flag.InternalFlag{ - Rollout: &flag.Rollout{ - Experimentation: &flag.ExperimentationRollout{ - Start: testconvert.Time(time.Now().Add(-2 * time.Second)), - End: testconvert.Time(time.Now().Add(2 * time.Second)), - }, - }, + Scheduled: &[]flag.ScheduledStep{ + { + InternalFlag: flag.InternalFlag{ + Experimentation: &flag.ExperimentationRollout{ + Start: testconvert.Time(time.Now().Add(-2 * time.Second)), + End: testconvert.Time(time.Now().Add(2 * time.Second)), }, - Date: testconvert.Time(time.Now().Add(-1 * time.Second)), }, + Date: testconvert.Time(time.Now().Add(-1 * time.Second)), }, }, }, @@ -870,29 +844,25 @@ func TestInternalFlag_Value(t *testing.T) { DefaultRule: &flag.Rule{ VariationResult: testconvert.String("variation_A"), }, - Rollout: &flag.Rollout{ - Scheduled: &[]flag.ScheduledStep{ - { - InternalFlag: flag.InternalFlag{ - Variations: &map[string]*interface{}{ - "variation_A": testconvert.Interface("value_AB"), - "variation_B": testconvert.Interface("value_B"), - }, - Rollout: &flag.Rollout{ - Scheduled: &[]flag.ScheduledStep{ - { - InternalFlag: flag.InternalFlag{ - Variations: &map[string]*interface{}{ - "variation_A": testconvert.Interface("value_ABC"), - }, - }, - Date: testconvert.Time(time.Now().Add(-3 * time.Second)), + Scheduled: &[]flag.ScheduledStep{ + { + InternalFlag: flag.InternalFlag{ + Variations: &map[string]*interface{}{ + "variation_A": testconvert.Interface("value_AB"), + "variation_B": testconvert.Interface("value_B"), + }, + Scheduled: &[]flag.ScheduledStep{ + { + InternalFlag: flag.InternalFlag{ + Variations: &map[string]*interface{}{ + "variation_A": testconvert.Interface("value_ABC"), }, }, + Date: testconvert.Time(time.Now().Add(-3 * time.Second)), }, }, - Date: testconvert.Time(time.Now().Add(-2 * time.Second)), }, + Date: testconvert.Time(time.Now().Add(-2 * time.Second)), }, }, }, @@ -1127,13 +1097,15 @@ func TestInternalFlag_GetVariationValue(t *testing.T) { func TestInternalFlag_IsValid(t *testing.T) { type fields struct { - Variations *map[string]*interface{} - Rules *[]flag.Rule - DefaultRule *flag.Rule - Rollout *flag.Rollout - TrackEvents *bool - Disable *bool - Version *string + Variations *map[string]*interface{} + Rules *[]flag.Rule + DefaultRule *flag.Rule + Rollout *flag.Rollout + TrackEvents *bool + Disable *bool + Version *string + Experimentation *flag.ExperimentationRollout + Scheduled *[]flag.ScheduledStep } tests := []struct { name string @@ -1350,13 +1322,14 @@ func TestInternalFlag_IsValid(t *testing.T) { for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { f := &flag.InternalFlag{ - Variations: tt.fields.Variations, - Rules: tt.fields.Rules, - DefaultRule: tt.fields.DefaultRule, - Rollout: tt.fields.Rollout, - TrackEvents: tt.fields.TrackEvents, - Disable: tt.fields.Disable, - Version: tt.fields.Version, + Variations: tt.fields.Variations, + Rules: tt.fields.Rules, + DefaultRule: tt.fields.DefaultRule, + TrackEvents: tt.fields.TrackEvents, + Disable: tt.fields.Disable, + Version: tt.fields.Version, + Scheduled: tt.fields.Scheduled, + Experimentation: tt.fields.Experimentation, } err := f.IsValid() errMsg := "" diff --git a/notifier/slacknotifier/notifier_test.go b/notifier/slacknotifier/notifier_test.go index dbed325a26c..3def3d042f5 100644 --- a/notifier/slacknotifier/notifier_test.go +++ b/notifier/slacknotifier/notifier_test.go @@ -107,11 +107,9 @@ func TestSlackNotifier_Notify(t *testing.T) { "True": 100, }, }, - Rollout: &flag.Rollout{ - Experimentation: &flag.ExperimentationRollout{ - Start: testconvert.Time(time.Unix(1095379400, 0)), - End: testconvert.Time(time.Unix(1095371000, 0)), - }, + Experimentation: &flag.ExperimentationRollout{ + Start: testconvert.Time(time.Unix(1095379400, 0)), + End: testconvert.Time(time.Unix(1095371000, 0)), }, }, After: &flag.InternalFlag{ diff --git a/notifier/slacknotifier/testdata/should_call_webhook_and_have_valid_results.json b/notifier/slacknotifier/testdata/should_call_webhook_and_have_valid_results.json index a7de0f6fad6..cc5e97ed044 100644 --- a/notifier/slacknotifier/testdata/should_call_webhook_and_have_valid_results.json +++ b/notifier/slacknotifier/testdata/should_call_webhook_and_have_valid_results.json @@ -29,8 +29,8 @@ "short": true }, { - "title": "Rollout", - "value": "(*flag.Rollout){Experimentation:(*flag.ExperimentationRollout){Start:(*time.Time){wall:0, ext:63230976200, loc:(*time.Location){name:\"\", zone:[]time.zone(nil), tx:[]time.zoneTrans(nil), extend:\"\", cacheStart:0, cacheEnd:0, cacheZone:(*time.zone)(nil)}}, End:(*time.Time){wall:0, ext:63230967800, loc:(*time.Location){name:\"\", zone:[]time.zone(nil), tx:[]time.zoneTrans(nil), extend:\"\", cacheStart:0, cacheEnd:0, cacheZone:(*time.zone)(nil)}}}, Scheduled:(*[]flag.ScheduledStep)(nil)} =\u003e nil", + "title": "Experimentation", + "value": "(*flag.ExperimentationRollout){Start:(*time.Time){wall:0, ext:63230976200, loc:(*time.Location){name:\"\", zone:[]time.zone(nil), tx:[]time.zoneTrans(nil), extend:\"\", cacheStart:0, cacheEnd:0, cacheZone:(*time.zone)(nil)}}, End:(*time.Time){wall:0, ext:63230967800, loc:(*time.Location){name:\"\", zone:[]time.zone(nil), tx:[]time.zoneTrans(nil), extend:\"\", cacheStart:0, cacheEnd:0, cacheZone:(*time.zone)(nil)}}} =\u003e nil", "short": false }, { From c3f782dd7e212a484b84e261f26771cab67579b9 Mon Sep 17 00:00:00 2001 From: Thomas Poignant Date: Tue, 4 Oct 2022 09:00:38 +0200 Subject: [PATCH 38/50] update doc Signed-off-by: Thomas Poignant --- README.md | 176 +++++++----- docs/configuration.md | 24 +- docs/data_collection/file.md | 12 +- docs/data_collection/index.md | 69 +++-- docs/data_collection/log.md | 4 +- docs/data_collection/s3.md | 14 +- docs/data_collection/webhook.md | 10 +- docs/flag_file/file.md | 6 +- docs/flag_file/github.md | 12 +- docs/flag_file/google_cloud_storage.md | 8 +- docs/flag_file/s3.md | 10 +- docs/flag_format.md | 362 +++++++++++++++++++------ docs/index.md | 2 +- docs/notifier/index.md | 2 +- docs/notifier/slack.md | 6 +- docs/notifier/webhook.md | 111 +++++--- docs/rollout/canary.md | 44 +-- docs/rollout/experimentation.md | 74 ++--- docs/rollout/index.md | 2 +- docs/rollout/progressive.md | 82 +++--- docs/rollout/scheduled.md | 119 +++++--- 21 files changed, 746 insertions(+), 403 deletions(-) diff --git a/README.md b/README.md index 01f77d8984e..f1c36a19162 100644 --- a/README.md +++ b/README.md @@ -30,7 +30,7 @@ go get github.com/thomaspoignant/go-feature-flag ``` ## What is go-feature-flag? -A simple and complete feature flag solution, without any complex backend system to install, all you need is a file as your backend. +GO Feature Flag is the easiest way to start with feature flag without any complex backend system to install, all you need is a file as your backend. No server is needed, just add a file to your central system and all your services will react to the changes in this file. @@ -58,7 +58,7 @@ _The code of this demo is available in [`thomaspoignant/go-feature-flag-demo`](h ## Can I use GO Feature Flag with another language? -Originally GO Feature Flag was built to be a GOlang only library, but it limits the ecsystem too much. +Originally GO Feature Flag was built to be a GOlang only library, but it limits the ecosystem too much. To be compatible with more language we have implemented the [GO Feature Flag Relay Proxy](https://github.com/thomaspoignant/go-feature-flag-relay-proxy). It is a service you can host that provides an API to evaluate your flags, you can call it using HTTP to get your variation. @@ -169,27 +169,38 @@ If you prefer to do it manually please follow instruction bellow. YAML ```yaml -test-flag: - percentage: 100 - rule: key eq "random-key" - true: true - false: false - default: false - disable: false - trackEvents: true - version: 1 - rollout: - experimentation: - start: 2021-03-20T00:00:00.10-05:00 - end: 2021-03-21T00:00:00.10-05:00 - - test-flag2: - rule: key eq "not-a-key" - percentage: 100 - true: true - false: false - default: false - version: 12 +# This is your configuration for your first flag +first-flag: + variations: # All possible return value for your feature flag + A: false + B: true + targeting: # If you want to target a subset of your users in particular + - query: key eq "random-key" + percentage: + A: 0 + B: 100 + defaultRule: # When no targeting match we use the defaultRule + variation: A + +# A second example of a flag configuration +second-flag: + variations: + A: "valueA" + B: "valueB" + defaultValue: "a default value" + targeting: + - name: legacyRuleV0 + query: key eq "not-a-key" + percentage: + A: 10 + B: 90 + defaultRule: + name: legacyDefaultRule + variation: defaultValue + version: "12" + experimentation: + start: 2021-03-20T00:00:00.1-05:00 + end: 2021-03-21T00:00:00.1-05:00 ```
@@ -197,29 +208,50 @@ test-flag: ```json { - "test-flag": { - "percentage": 100, - "rule": "key eq \"random-key\"", - "true": true, - "false": false, - "default": false, - "disable": false, - "trackEvents": true, - "version": 1, - "rollout": { - "experimentation": { - "start": "2021-03-20T05:00:00.100Z", - "end": "2021-03-21T05:00:00.100Z" + "first-flag": { + "variations": { + "A": false, + "B": true + }, + "targeting": [ + { + "query": "key eq \"random-key\"", + "percentage": { + "A": 0, + "B": 100 + } } + ], + "defaultRule": { + "variation": "A" } }, - "test-flag2": { - "rule": "key eq \"not-a-key\"", - "percentage": 100, - "true": true, - "false": false, - "default": false, - "version": 12 + + "second-flag": { + "variations": { + "A": "valueA", + "B": "valueB", + "defaultValue": "a default value" + }, + "targeting": [ + { + "name": "legacyRuleV0", + "query": "key eq \"not-a-key\"", + "percentage": { + "A": 10, + "B": 90 + } + } + ], + "defaultRule": { + "name": "legacyDefaultRule", + "variation": "defaultValue" + }, + "version": "12", + "experimentation": { + "start": "2021-03-20T05:00:00.100Z", + "end": "2021-03-21T05:00:00.100Z" + } } } ``` @@ -230,29 +262,43 @@ test-flag: TOML ```toml -[test-flag] -percentage = 100.0 -rule = "key eq \"random-key\"" -true = true -false = false -default = false -disable = false -trackEvents = true -version = 1.0 - -[test-flag.rollout] - - [test-flag.rollout.experimentation] +[first-flag.variations] +A = false +B = true + +[[first-flag.targeting]] +query = 'key eq "random-key"' + + [first-flag.targeting.percentage] + A = 0 + B = 100 + +[first-flag.defaultRule] +variation = "A" + +[second-flag] +version = "12" + + [second-flag.variations] + A = "valueA" + B = "valueB" + defaultValue = "a default value" + + [[second-flag.targeting]] + name = "legacyRuleV0" + query = 'key eq "not-a-key"' + + [second-flag.targeting.percentage] + A = 10 + B = 90 + + [second-flag.defaultRule] + name = "legacyDefaultRule" + variation = "defaultValue" + + [second-flag.experimentation] start = 2021-03-20T05:00:00.100Z end = 2021-03-21T05:00:00.100Z - -[test-flag2] -rule = "key eq \"not-a-key\"" -percentage = 100.0 -true = true -false = false -default = false -version = 12.0 ```
@@ -261,7 +307,7 @@ All the fields to create a flag are described in the [documentation](https://doc ## Rule format -The rule format is based on the [`nikunjy/rules`](https://github.com/nikunjy/rules) library. +The query format is based on the [`nikunjy/rules`](https://github.com/nikunjy/rules) library. All the operations can be written capitalized or lowercase (ex: `eq` or `EQ` can be used). Logical Operations supported are `AND` `OR`. diff --git a/docs/configuration.md b/docs/configuration.md index da3d375a813..3d2b9285cf8 100644 --- a/docs/configuration.md +++ b/docs/configuration.md @@ -10,18 +10,18 @@ During the initialization you must give a [`ffclient.Config{}`](https://pkg.go.d ## Configuration fields -| Field | Description | -|---|---| -|`Retriever` | The configuration retriever you want to use to get your flag file
*See [Store your flag file](flag_file/index.md) for the configuration details*.| -|`Context` | *(optional)*
The context used by the retriever.
Default: `context.Background()`| -|`Environment` | *(optional)*
The environment the app is running under, can be checked in feature flag rules.
Default: `""`
*Check [**"environments"** section](../flag_format/#environments) to understand how to use this parameter.*| -|`DataExporter` | *(optional)*
DataExporter defines how to export data on how your flags are used.
*see [export data section](data_collection/index.md) for more details*.| -|`FileFormat`| *(optional)*
Format of your configuration file. Available formats are `yaml`, `toml` and `json`, if you omit the field it will try to unmarshal the file as a `yaml` file.
Default: `YAML`| -|`Logger` | *(optional)*
Logger used to log what `go-feature-flag` is doing.
If no logger is provided the module will not log anything.
Default: No log| -|`Notifiers` | *(optional)*
List of notifiers to call when your flag file has been changed.
*See [notifiers section](./notifier/index.md) for more details*.| -|`PollingInterval` | (optional) Duration to wait before refreshing the flags.
The minimum polling interval is 1 second.
Default: 60 * time.Second| -|`StartWithRetrieverError` | *(optional)* If **true**, the SDK will start even if we did not get any flags from the retriever. It will serve only default values until the retriever returns the flags.
The init method will not return any error if the flag file is unreachable.
Default: **false**| -|`Offline`| *(optional)* If **true**, the SDK will not try to retrieve the flag file and will not export any data. No notification will be send neither.
Default: false| +| Field | Description | +|---------------------------|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------| +| `Retriever` | The configuration retriever you want to use to get your flag file
*See [Store your flag file](flag_file/index.md) for the configuration details*. | +| `Context` | *(optional)*
The context used by the retriever.
Default: `context.Background()` | +| `Environment` | *(optional)*
The environment the app is running under, can be checked in feature flag rules.
Default: `""`
*Check [**"environments"** section](../flag_format/#environments) to understand how to use this parameter.* | +| `DataExporter` | *(optional)*
DataExporter defines how to export data on how your flags are used.
*see [export data section](data_collection/index.md) for more details*. | +| `FileFormat` | *(optional)*
Format of your configuration file. Available formats are `yaml`, `toml` and `json`, if you omit the field it will try to unmarshal the file as a `yaml` file.
Default: `YAML` | +| `Logger` | *(optional)*
Logger used to log what `go-feature-flag` is doing.
If no logger is provided the module will not log anything.
Default: No log | +| `Notifiers` | *(optional)*
List of notifiers to call when your flag file has been changed.
*See [notifiers section](./notifier/index.md) for more details*. | +| `PollingInterval` | (optional) Duration to wait before refreshing the flags.
The minimum polling interval is 1 second.
Default: 60 * time.Second | +| `StartWithRetrieverError` | *(optional)* If **true**, the SDK will start even if we did not get any flags from the retriever. It will serve only default values until the retriever returns the flags.
The init method will not return any error if the flag file is unreachable.
Default: **false** | +| `Offline` | *(optional)* If **true**, the SDK will not try to retrieve the flag file and will not export any data. No notification will be send neither.
Default: false | ## Example ```go linenums="1" diff --git a/docs/data_collection/file.md b/docs/data_collection/file.md index ec0f92d06f9..904b1f0c571 100644 --- a/docs/data_collection/file.md +++ b/docs/data_collection/file.md @@ -27,11 +27,11 @@ ffclient.Config{ ## Configuration fields -| Field | Description | -|---|---| -|`OutputDir` | OutputDir is the location of the directory where to store the exported files.
It should finish with a `/`. | -|`Format` | _(Optional)_ Format is the output format you want in your exported file.
Available format: **`JSON`**, **`CSV`**.
**Default: `JSON`** | -|`Filename` | _(Optional)_ Filename is the name of your output file.
You can use a templated config to define the name of your exported files.
Available replacement are `{{ .Hostname}}`, `{{ .Timestamp}}` and `{{ .Format}}`
**Default: `flag-variation-{{ .Hostname}}-{{ .Timestamp}}.{{ .Format}}`**| -|`CsvTemplate` | _(Optional)_ CsvTemplate is used if your output format is CSV.
This field will be ignored if you are using another format than CSV.
You can decide which fields you want in your CSV line with a go-template syntax, please check [internal/exporter/feature_event.go](https://github.com/thomaspoignant/go-feature-flag/blob/main/internal/exporter/feature_event.go) to see what are the fields available.
**Default:** `{{ .Kind}};{{ .ContextKind}};{{ .UserKey}};{{ .CreationDate}};{{ .Key}};{{ .Variation}};{{ .Value}};{{ .Default}}\n` | +| Field | Description | +|---------------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------| +| `OutputDir` | OutputDir is the location of the directory where to store the exported files.
It should finish with a `/`. | +| `Format` | _(Optional)_ Format is the output format you want in your exported file.
Available format: **`JSON`**, **`CSV`**.
**Default: `JSON`** | +| `Filename` | _(Optional)_ Filename is the name of your output file.
You can use a templated config to define the name of your exported files.
Available replacement are `{{ .Hostname}}`, `{{ .Timestamp}}` and `{{ .Format}}`
**Default: `flag-variation-{{ .Hostname}}-{{ .Timestamp}}.{{ .Format}}`** | +| `CsvTemplate` | _(Optional)_ CsvTemplate is used if your output format is CSV.
This field will be ignored if you are using another format than CSV.
You can decide which fields you want in your CSV line with a go-template syntax, please check [internal/exporter/feature_event.go](https://github.com/thomaspoignant/go-feature-flag/blob/main/internal/exporter/feature_event.go) to see what are the fields available.
**Default:** `{{ .Kind}};{{ .ContextKind}};{{ .UserKey}};{{ .CreationDate}};{{ .Key}};{{ .Variation}};{{ .Value}};{{ .Default}}\n` | Check the [godoc for full details](https://pkg.go.dev/github.com/thomaspoignant/go-feature-flag/exporter/fileexporter). diff --git a/docs/data_collection/index.md b/docs/data_collection/index.md index 9f716d010bc..4e1ff2fe830 100644 --- a/docs/data_collection/index.md +++ b/docs/data_collection/index.md @@ -37,16 +37,16 @@ It represents individual flag evaluations and are considered "full fidelity" eve ### Configuration fields -| Field | Description | -|--------------------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------| -| **`kind`** | The kind for a feature event is feature. A feature event will only be generated if the trackEvents attribute of the flag is set to true. | -| **`contextKind`** | The kind of context which generated an event. This will only be "**anonymousUser**" for events generated on behalf of an anonymous user or the reserved word "**user**" for events generated on behalf of a non-anonymous user | -| **`userKey`** | The key of the user object used in a feature flag evaluation. | -| **`creationDate`** | When the feature flag was requested at Unix epoch time in milliseconds. | -| **`key`** | The key of the feature flag requested. | +| Field | Description | +|--------------------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------| +| **`kind`** | The kind for a feature event is feature. A feature event will only be generated if the trackEvents attribute of the flag is set to true. | +| **`contextKind`** | The kind of context which generated an event. This will only be "**anonymousUser**" for events generated on behalf of an anonymous user or the reserved word "**user**" for events generated on behalf of a non-anonymous user | +| **`userKey`** | The key of the user object used in a feature flag evaluation. | +| **`creationDate`** | When the feature flag was requested at Unix epoch time in milliseconds. | +| **`key`** | The key of the feature flag requested. | | **`variation`** | The variation of the flag requested. Available values are:
**True**: if the flag was evaluated to True
**False**: if the flag was evaluated to False
**Dafault**: if the flag was evaluated to Default
**SdkDefault**: if something wrong happened and the SDK default value was used. | -| **`value`** | The value of the feature flag returned by feature flag evaluation. | -| **`default`** | (Optional) This value is set to true if feature flag evaluation failed, in which case the value returned was the default value passed to variation. | +| **`value`** | The value of the feature flag returned by feature flag evaluation. | +| **`default`** | (Optional) This value is set to true if feature flag evaluation failed, in which case the value returned was the default value passed to variation. | Events are collected and send in bulk to avoid spamming your exporter *(see details in [how to configure data export](#how-to-configure-data-export)*) @@ -77,9 +77,9 @@ ffclient.Config{ ### Configuration fields -| Field | | Description | -|--------------------|--------------------------------------------------------------------------------------------------------------------------------------|-------------| -| `Exporter` | The configuration of the exporter you want to use. All the exporters are available in the `exporter` package. | +| Field | | Description | +|--------------------|----------------------------------------------------------------------------------------------------------------------------------------|-------------| +| `Exporter` | The configuration of the exporter you want to use. All the exporters are available in the `exporter` package. | | `FlushInterval` | *(optional)*
Time to wait before exporting the data.
**Default: 60 seconds**. | | `MaxEventInMemory` | *(optional)*
If `MaxEventInMemory` is reach before the `FlushInterval` a intermediary export will be done
**Default: 100000**. | @@ -92,23 +92,32 @@ If you want to exclude a specific flag from the data export, you can set the pro === "YAML" ``` yaml linenums="1" hl_lines="6" -test-flag: - percentage: 50 - true: "B" - false: "A" - default: "Default" - trackEvents: false +untracked-flag: + variations: + A: false + B: true + defaultRule: + percentage: + A: 0 + B: 100 + trackEvents: false # Deactivate tracking ``` === "JSON" ``` json linenums="1" hl_lines="7" { - "test-flag": { - "percentage": 50, - "true": "B", - "false": "A", - "default": "Default", + "untracked-flag": { + "variations": { + "A": false, + "B": true + }, + "defaultRule": { + "percentage": { + "A": 0, + "B": 100 + } + }, "trackEvents": false } } @@ -117,10 +126,14 @@ test-flag: === "TOML" ``` toml linenums="1" hl_lines="6" -[test-flag] -percentage = 50.0 -true = "B" -false = "A" -default = "Default" +[untracked-flag] trackEvents = false + + [untracked-flag.variations] + A = false + B = true + +[untracked-flag.defaultRule.percentage] +A = 0 +B = 100 ``` diff --git a/docs/data_collection/log.md b/docs/data_collection/log.md index c0b8bfdd56c..d0f199d744a 100644 --- a/docs/data_collection/log.md +++ b/docs/data_collection/log.md @@ -23,8 +23,8 @@ ffclient.Config{ ``` ## Configuration fields -| Field | Description | -|-------------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------| +| Field | Description | +|-------------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------| | `LogFormat` | *(optional)*
LogFormat is the [template](https://golang.org/pkg/text/template/) configuration of the output format of your log.
You can use all the key from the `exporter.FeatureEvent` + a key called `FormattedDate` that represent the date with the **RFC 3339** Format.

**Default: `[{{ .FormattedDate}}] user="{{ .UserKey}}", flag="{{ .Key}}", value="{{ .Value}}"`** | Check the [godoc for full details](https://pkg.go.dev/github.com/thomaspoignant/go-feature-flag/exporter/logsexporter). diff --git a/docs/data_collection/s3.md b/docs/data_collection/s3.md index 24f7a89b7bb..90769188570 100644 --- a/docs/data_collection/s3.md +++ b/docs/data_collection/s3.md @@ -40,13 +40,13 @@ ffclient.Config{ ## Configuration fields -| Field | Description | -|---------------|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------| -| `Bucket` | Name of your S3 Bucket. | -| `AwsConfig` | An instance of `aws.Config` that configure your access to AWS *(see [this documentation for more info](https://docs.aws.amazon.com/sdk-for-go/v1/developer-guide/configuring-sdk.html))*. | +| Field | Description | +|---------------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------| +| `Bucket` | Name of your S3 Bucket. | +| `AwsConfig` | An instance of `aws.Config` that configure your access to AWS *(see [this documentation for more info](https://docs.aws.amazon.com/sdk-for-go/v1/developer-guide/configuring-sdk.html))*. | | `CsvTemplate` | *(optional)* CsvTemplate is used if your output format is CSV. This field will be ignored if you are using another format than CSV. You can decide which fields you want in your CSV line with a go-template syntax, please check [internal/exporter/feature_event.go](https://github.com/thomaspoignant/go-feature-flag/blob/main/internal/exporter/feature_event.go) to see what are the fields available.
**Default:** `{{ .Kind}};{{ .ContextKind}};{{ .UserKey}};{{ .CreationDate}};{{ .Key}};{{ .Variation}};{{ .Value}};{{ .Default}}\n` | -| `Filename` | *(optional)* Filename is the name of your output file. You can use a templated config to define the name of your exported files.
Available replacement are `{{ .Hostname}}`, `{{ .Timestamp}`} and `{{ .Format}}`
Default: `flag-variation-{{ .Hostname}}-{{ .Timestamp}}.{{ .Format}}` | -| `Format` | *(optional)* Format is the output format you want in your exported file. Available format are **`JSON`** and **`CSV`**. *(Default: `JSON`)* | -| `S3Path` | *(optional)* The location of the directory in S3. | +| `Filename` | *(optional)* Filename is the name of your output file. You can use a templated config to define the name of your exported files.
Available replacement are `{{ .Hostname}}`, `{{ .Timestamp}`} and `{{ .Format}}`
Default: `flag-variation-{{ .Hostname}}-{{ .Timestamp}}.{{ .Format}}` | +| `Format` | *(optional)* Format is the output format you want in your exported file. Available format are **`JSON`** and **`CSV`**. *(Default: `JSON`)* | +| `S3Path` | *(optional)* The location of the directory in S3. | Check the [godoc for full details](https://pkg.go.dev/github.com/thomaspoignant/go-feature-flag/exporter/s3exporter). diff --git a/docs/data_collection/webhook.md b/docs/data_collection/webhook.md index 5f094f52f58..a4ca1bc2e3c 100644 --- a/docs/data_collection/webhook.md +++ b/docs/data_collection/webhook.md @@ -28,11 +28,11 @@ ffclient.Config{ } ``` ## Configuration fields -| Field | Description | -|---|---| -|`EndpointURL ` | EndpointURL of your webhook | -|`Secret ` | *(optional)*
Secret used to sign your request body and fill the `X-Hub-Signature-256` header.
See [signature section](#signature) for more details. | -|`Meta` | *(optional)*
Add all the information you want to see in your request. | +| Field | Description | +|----------------|-------------------------------------------------------------------------------------------------------------------------------------------------------------| +| `EndpointURL ` | EndpointURL of your webhook | +| `Secret ` | *(optional)*
Secret used to sign your request body and fill the `X-Hub-Signature-256` header.
See [signature section](#signature) for more details. | +| `Meta` | *(optional)*
Add all the information you want to see in your request. | ## Webhook format diff --git a/docs/flag_file/file.md b/docs/flag_file/file.md index 4ed4f62d0c9..7582bc44e17 100644 --- a/docs/flag_file/file.md +++ b/docs/flag_file/file.md @@ -25,6 +25,6 @@ defer ffclient.Close() ## Configuration fields To configure your File retriever: -| Field | Description | -|---|---| -|**`Path`**| location of your file on the file system.| +| Field | Description | +|------------|-------------------------------------------| +| **`Path`** | location of your file on the file system. | diff --git a/docs/flag_file/github.md b/docs/flag_file/github.md index d405d6eb982..cc59652306d 100644 --- a/docs/flag_file/github.md +++ b/docs/flag_file/github.md @@ -30,10 +30,10 @@ defer ffclient.Close() To configure the access to your GitHub file: -| Field | Description | -|----------------------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------| -| **`RepositorySlug`** | Your GitHub slug `org/repo-name`. | -| **`FilePath`** | The path of your file. | -| **`Branch`** | *(optional)*
The branch where your file is.
Default: `main` | +| Field | Description | +|----------------------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------| +| **`RepositorySlug`** | Your GitHub slug `org/repo-name`. | +| **`FilePath`** | The path of your file. | +| **`Branch`** | *(optional)*
The branch where your file is.
Default: `main` | | **`GithubToken`** | *(optional)*
Github token is used to access a private repository, you need the `repo` permission *([how to create a GitHub token](https://docs.github.com/en/free-pro-team@latest/github/authenticating-to-github/creating-a-personal-access-token))*. | -| **`Timeout`** | *(optional)*
Timeout for the HTTP call
Default: 10 seconds | +| **`Timeout`** | *(optional)*
Timeout for the HTTP call
Default: 10 seconds | diff --git a/docs/flag_file/google_cloud_storage.md b/docs/flag_file/google_cloud_storage.md index 3094584fbd6..3182b4f6270 100644 --- a/docs/flag_file/google_cloud_storage.md +++ b/docs/flag_file/google_cloud_storage.md @@ -28,8 +28,8 @@ defer ffclient.Close() To configure your Google Cloud Storage file location: -| Field | Description | -|--------------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------| -| **`Bucket`** | The name of your bucket. | -| **`Object`** | The name of your object in your bucket. | +| Field | Description | +|--------------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------| +| **`Bucket`** | The name of your bucket. | +| **`Object`** | The name of your object in your bucket. | | **`Option`** | An instance of `option.ClientOption` that configures your access to Google Cloud.
Check [this documentation for more info](https://cloud.google.com/docs/authentication). | diff --git a/docs/flag_file/s3.md b/docs/flag_file/s3.md index 97be051359f..d62e3c6df39 100644 --- a/docs/flag_file/s3.md +++ b/docs/flag_file/s3.md @@ -23,8 +23,8 @@ defer ffclient.Close() ## Configuration fields To configure your S3 file location: -| Field | Description | -|---|---| -|**`Bucket`**| The name of your bucket.| -|**`Item`**| The location of your file in the bucket.| -|**`AwsConfig`**| An instance of `aws.Config` that configure your access to AWS
*check [this documentation for more info](https://docs.aws.amazon.com/sdk-for-go/v1/developer-guide/configuring-sdk.html)*.| +| Field | Description | +|-----------------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------| +| **`Bucket`** | The name of your bucket. | +| **`Item`** | The location of your file in the bucket. | +| **`AwsConfig`** | An instance of `aws.Config` that configure your access to AWS
*check [this documentation for more info](https://docs.aws.amazon.com/sdk-for-go/v1/developer-guide/configuring-sdk.html)*. | diff --git a/docs/flag_format.md b/docs/flag_format.md index 33f85daa39b..cc59adf9edf 100644 --- a/docs/flag_format.md +++ b/docs/flag_format.md @@ -12,13 +12,13 @@ Your file must be a valid `YAML`, `JSON` or `TOML` file with a list of flags [`TOML`](https://github.com/thomaspoignant/go-feature-flag/tree/main/testdata/flag-config.toml))*. The easiest way to create your configuration file is to used -[**GO Feature Flag Editor** available at https://thomaspoignant.github.io/go-feature-flag-editor/](https://thomaspoignant.github.io/go-feature-flag-editor/). +[**GO Feature Flag Editor** available at [https://editor.gofeatureflag.org](https://editor.gofeatureflag.org). If you prefer to do it manually please follow instruction bellow. ## Editor Creating the first version of the flag is not always pleasant, that's why we have created -[**GO Feature Flag Editor**](https://thomaspoignant.github.io/go-feature-flag-editor/) a simple editor to create your files. +[**GO Feature Flag Editor**](https://editor.gofeatureflag.org) a simple editor to create your files. ## Example @@ -27,56 +27,88 @@ A flag configuration looks like: === "YAML" ``` yaml linenums="1" -test-flag: - percentage: 100 - rule: key eq "random-key" - true: true - false: false - default: false - disable: false - trackEvents: true - version: 1 - rollout: - experimentation: - start: 2021-03-20T00:00:00.10-05:00 - end: 2021-03-21T00:00:00.10-05:00 - -test-flag2: - rule: key eq "not-a-key" - percentage: 100 - true: true - false: false - default: false - version: 12 +# This is your configuration for your first flag +first-flag: + variations: # All possible return value for your feature flag + A: false + B: true + targeting: # If you want to target a subset of your users in particular + - query: key eq "random-key" + percentage: + A: 0 + B: 100 + defaultRule: # When no targeting match we use the defaultRule + variation: A + +# A second example of a flag configuration +second-flag: + variations: + A: "valueA" + B: "valueB" + defaultValue: "a default value" + targeting: + - name: legacyRuleV0 + query: key eq "not-a-key" + percentage: + A: 10 + B: 90 + defaultRule: + name: legacyDefaultRule + variation: defaultValue + version: "12" + experimentation: + start: 2021-03-20T00:00:00.1-05:00 + end: 2021-03-21T00:00:00.1-05:00 ``` === "JSON" ``` json linenums="1" { - "test-flag": { - "percentage": 100, - "rule": "key eq \"random-key\"", - "true": true, - "false": false, - "default": false, - "disable": false, - "trackEvents": true, - "version": 1, - "rollout": { - "experimentation": { - "start": "2021-03-20T05:00:00.100Z", - "end": "2021-03-21T05:00:00.100Z" + "first-flag": { + "variations": { + "A": false, + "B": true + }, + "targeting": [ + { + "query": "key eq \"random-key\"", + "percentage": { + "A": 0, + "B": 100 + } } + ], + "defaultRule": { + "variation": "A" } }, - "test-flag2": { - "rule": "key eq \"not-a-key\"", - "percentage": 100, - "true": true, - "false": false, - "default": false, - "version": 12 + + "second-flag": { + "variations": { + "A": "valueA", + "B": "valueB", + "defaultValue": "a default value" + }, + "targeting": [ + { + "name": "legacyRuleV0", + "query": "key eq \"not-a-key\"", + "percentage": { + "A": 10, + "B": 90 + } + } + ], + "defaultRule": { + "name": "legacyDefaultRule", + "variation": "defaultValue" + }, + "version": "12", + "experimentation": { + "start": "2021-03-20T05:00:00.100Z", + "end": "2021-03-21T05:00:00.100Z" + } } } ``` @@ -84,48 +116,220 @@ test-flag2: === "TOML" ``` toml linenums="1" -[test-flag] -percentage = 100.0 -rule = "key eq \"random-key\"" -true = true -false = false -default = false -disable = false -trackEvents = true -version = 1.0 - -[test-flag.rollout] - - [test-flag.rollout.experimentation] - start = 2021-03-20T05:00:00.100Z - end = 2021-03-21T05:00:00.100Z - -[test-flag2] -rule = "key eq \"not-a-key\"" -percentage = 100.0 -true = true -false = false -default = false -version = 12.0 +[first-flag.variations] +A = false +B = true + +[[first-flag.targeting]] +query = 'key eq "random-key"' + + [first-flag.targeting.percentage] + A = 0 + B = 100 + +[first-flag.defaultRule] +variation = "A" + +[second-flag] +version = "12" + + [second-flag.variations] + A = "valueA" + B = "valueB" + defaultValue = "a default value" + + [[second-flag.targeting]] + name = "legacyRuleV0" + query = 'key eq "not-a-key"' + + [second-flag.targeting.percentage] + A = 10 + B = 90 + + [second-flag.defaultRule] + name = "legacyDefaultRule" + variation = "defaultValue" + + [second-flag.experimentation] + start = 2021-03-20T05:00:00.100Z + end = 2021-03-21T05:00:00.100Z ``` ## Format details -| Field | Description | -|:-------------:|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------| -| **flag-key** | Name of your flag.
It must be unique.
*On the example the flag keys are **`test-flag`** and **`test-flag2`**.* | -| `true` | Value returned by the flag if apply to the user *(rule is evaluated to true)* and the user is in the active percentage. | -| `false` | Value returned by the flag if apply to the user *(rule is evaluated to true)* and the user is **not** in the active percentage. | -| `default` | Value returned by the flag if not apply to the user *(rule is evaluated to false).* | -| `percentage` | *(optional)*
Percentage of the users who should be affected by the flag.
**Default: 0**

The percentage is computed by calculating a hash of the user key *(100000 variations)*, it means that you can have 3 numbers after the comma. | -| `rule` | *(optional)*
Condition to determine on which user the flag should be applied.
Rule format is described in the [rule format section](#rule-format).
**If no rule is set, the flag applies to all users *(percentage still apply)*.** | -| `disable` | *(optional)*
True if the flag is disabled.
**Default: `false`** | -| `trackEvents` | *(optional)*
False if you don't want to export the data in your data exporter.
**Default: `true`** | -| `version` | *(optional)*
The version is the version of your flag.
This number is used to display the information in the notifiers and data collection, you have to update it your self.
**Default: 0** | -| `rollout` | *(optional)*
rollout contains a specific rollout strategy you want to use.
**See [rollout section](rollout/index.md) for more details.** | + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
FieldDescription
flag-keyName of your flag.
It must be unique.
On the example the flag keys are test-flag and test-flag2.
variations +

Variations are all the variations available for this flag.

It is represented as a key/value element. The key is the name of the variation and the value could be any types available (string, float, int, map, array, bool).

You can have as many variation as needed.

+ + ```yaml + # Some examples + variationString: test + variationBool: true + variationInt: 1000 + variationFloat: 1000.23 + variationArray: + - item1 + - item2 + variationObj: + item1: 123 + item2: this is a string + item3: false + ``` + +
targeting
(optional)		 +

Targeting contains the list of rules you have to target a subset of your users.
You can have as many target as needed.

+

This field is an array and contains a list of rules.

+

See rules format to have more info on how to write a rule.

+
defaultRule +

DefaultRule is the rule that is applied if the user does not match in any targeting.

+

See rules format to have more info on how to write a rule.

+
trackEvents
(optional)		 +

false if you don't want to export the data in your data exporter.

+

Default: true

+
disable
(optional)		 +

true if the flag is disabled.

+

Default: false

+
version
(optional)		 +

The version is the version of your flag.
This string is used to display the information in the notifiers and data collection, you have to update it your self.

+

Default: ""

+
scheduledRollout
(optional)		 +

Scheduled allow to patch your flag over time.

+

You can add several steps that updates the flag, this is typically used if you want to gradually add more user in your flag.

+

See Scheduled rollout to have more info on how to use it.

+
experimentation
(optional)		 +

Experimentation allow you to configure a start date and an end date for your flag. When the experimentation is not running, the flag will serve the default value.

+

See Experimentation rollout to have more info on how to use it.

+
+ ## Rule format +A rule is a configuration that allows to serve a variation based on some conditions. + +### Format details + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
FieldDescription
name
(optional)		Name of your rule.
This is needed when your are updating a rule using a scheduled rollout.
query +

+ Query represents an antlr query in the nikunjy/rules format. +
This field is mandatory in every rule used in the targeting field. +

+

See query format to have the syntax.

+

Note: if you use the field query in a defaultRule it will be ignored.

+
variation
(optional)		Name of the variation to return.
percentage
(optional)		 +

Represents the percentage we should give to each variation.

+

+ + ```yaml + percentage: + variationA: 10.59 + variationB: 9.41 + variationC: 80 + ``` + +

+

The format is the name of the variation and the percentage for this one.

+

Note: if your total is not equals to 100% this rule will be considered as invalid.

+ + +
progressiveRollout
(optional)		 +

Allow to ramp up the percentage of your flag over time.

+

You can decide at which percentage you starts with and at what percentage you ends with in your release ramp. + Before the start date we will serve the initial percentage and, after we will serve the end percentage. +

+

See progressive rollout to have more info on how to use it.

+ + +
disable
(optional)		 +

Set to true if you want to disable the rule.

+

Default: true.

+
+ + +!!! Info + `variation`, `percentage` and `progressiveRollout` are optional but you need to have one of the 3. + + If you have more than one field we will use the first one in that order + `progressiveRollout` > `percentage` > `variation`. + +### Query format + The rule format is based on the [`nikunjy/rules`](https://github.com/nikunjy/rules) library. All the operations can be written capitalized or lowercase (ex: `eq` or `EQ` can be used). @@ -148,7 +352,7 @@ Compare Expression and their definitions (`a|b` means you can use either one of | `pr` | present | | `not` | not of a logical expression | -### Examples +#### Examples - Select a specific user: `key eq "example@example.com"` - Select all identified users: `anonymous ne true` diff --git a/docs/index.md b/docs/index.md index f034363885d..39c186fe97c 100644 --- a/docs/index.md +++ b/docs/index.md @@ -39,7 +39,7 @@ I've also written an [article](https://medium.com/better-programming/feature-fla **go-feature-flags supports:** -- Storing your configuration flags file on various locations ([`HTTP`](./flag_file/http.md), [`S3`](./flag_file/s3.md), [`GitHub`](./flag_file/github.md), [`file`](./flag_file/file.md)). +- Storing your configuration flags file on various locations ([`HTTP`](./flag_file/http.md), [`S3`](./flag_file/s3.md), [`file`](./flag_file/file.md), [`kubernetes`](./flag_file/kubernetes_configmaps.md), and [more](./flag_file)). - Configuring your flags in various [format](flag_format.md) (`JSON`, `TOML` and `YAML`). - Adding complex [rules](flag_format.md#rule-format) to target your users. - Use complex rollout strategy for your flags : diff --git a/docs/notifier/index.md b/docs/notifier/index.md index 70d8a53b41c..7ed06d89118 100644 --- a/docs/notifier/index.md +++ b/docs/notifier/index.md @@ -13,5 +13,5 @@ A notifier will send one notification to the targeted system to inform them that Available notifiers are: -- [Slack](slack.md) - Get a slack message with the changes. +- [Slack](slack.md) - Get a Slack message with the changes. - [Webhook](webhook.md) - Call an API with the changes. diff --git a/docs/notifier/slack.md b/docs/notifier/slack.md index 97195bc0817..2545e2d955a 100644 --- a/docs/notifier/slack.md +++ b/docs/notifier/slack.md @@ -33,6 +33,6 @@ ffclient.Config{ ### Configuration fields -| Field | Description | -|---|---| -|`SlackWebhookURL` | The complete URL of your incoming webhook configured in Slack. | +| Field | Description | +|-------------------|----------------------------------------------------------------| +| `SlackWebhookURL` | The complete URL of your incoming webhook configured in Slack. | diff --git a/docs/notifier/webhook.md b/docs/notifier/webhook.md index ede7e75fd4b..9ae3c7ed8b0 100644 --- a/docs/notifier/webhook.md +++ b/docs/notifier/webhook.md @@ -28,9 +28,9 @@ ffclient.Config{ ## Configuration fields -| Field | Description | -|---------------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------| -| `EndpointURL` | The complete URL of your API *(we will send a POST request to this URL, [see format](#format))* | +| Field | Description | +|---------------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------| +| `EndpointURL` | The complete URL of your API *(we will send a POST request to this URL, [see format](#format))* | | `Secret` | *(optional)*
A secret key you can share with your webhook. We will use this key to sign the request *(see [signature section](#signature) for more details)*. | | `Meta` | *(optional)*
A list of key value that will be add in your request, this is super useful if you want to add information on the current running instance of your app.

**By default the hostname is always added in the meta information.** | @@ -61,47 +61,70 @@ If you have configured a webhook, a `POST` request will be sent to the `Endpoint ```json linenums="1" { - "meta":{ - "hostname": "server01" - }, - "flags":{ - "deleted": { - "test-flag": { - "rule": "key eq \"random-key\"", - "percentage": 100, - "true": true, - "false": false, - "default": false - } - }, - "added": { - "test-flag3": { - "percentage": 5, - "true": "test", - "false": "false", - "default": "default" - } - }, - "updated": { - "test-flag2": { - "old_value": { - "rule": "key eq \"not-a-key\"", - "percentage": 100, - "true": true, - "false": false, - "default": false - }, - "new_value": { - "disable": true, - "rule": "key eq \"not-a-key\"", - "percentage": 100, - "true": true, - "false": false, - "default": false - } - } - } - } + "meta": { + "hostname": "server01" + }, + "flags": { + "deleted": { + "untracked-flag": { + "variations": { + "A": false, + "B": true + }, + "defaultRule": { + "percentage": { + "A": 0, + "B": 100 + } + } + } + }, + "added": { + "test-flag3": { + "variations": { + "A": false, + "B": true + }, + "defaultRule": { + "percentage": { + "A": 80, + "B": 20 + } + }, + "trackEvents": false + } + }, + "updated": { + "test-flag2": { + "old-value": { + "variations": { + "A": false, + "B": true + }, + "defaultRule": { + "percentage": { + "A": 80, + "B": 20 + } + }, + "trackEvents": false + } + "new_value": { + "variations": { + "A": false, + "B": true + }, + "defaultRule": { + "percentage": { + "A": 80, + "B": 20 + } + }, + "trackEvents": true + } + } + } + } } ``` diff --git a/docs/rollout/canary.md b/docs/rollout/canary.md index 96884ec6984..7b10f027983 100644 --- a/docs/rollout/canary.md +++ b/docs/rollout/canary.md @@ -13,33 +13,45 @@ You just have to select a percentage of your users in your flag, and the `True` === "YAML" - ``` yaml linenums="1" hl_lines="5" + ``` yaml linenums="1" hl_lines="8" canary-flag: - true: true - false: false - default: false - percentage: 1 + variations: + oldBehavior: false + canary: true + defaultRule: + percentage: + oldBehavior: 99 + canary: 1 ``` === "JSON" - ``` json linenums="1" hl_lines="6" + ``` json linenums="1" hl_lines="10" { "canary-flag": { - "true": true, - "false": false, - "default": "false, - "percentage": 1 + "variations": { + "oldBehavior": false, + "canary": true + }, + "defaultRule": { + "percentage": { + "oldBehavior": 99, + "canary": 1 + } + } } } ``` === "TOML" - ``` toml linenums="1" hl_lines="5" - [canary-flag] - true = true - false = false - default = false - percentage = 1.0 + ``` toml linenums="1" hl_lines="7" + [canary-flag.variations] + oldBehavior = false + canary = true + + [canary-flag.defaultRule.percentage] + oldBehavior = 99 + canary = 1 + ``` diff --git a/docs/rollout/experimentation.md b/docs/rollout/experimentation.md index e22566733ae..77d27567937 100644 --- a/docs/rollout/experimentation.md +++ b/docs/rollout/experimentation.md @@ -5,40 +5,46 @@ sidebar_position: 3 # Experimentation rollout / A/B Testing An **experimentation rollout** is when your flag is configured to be served only for a determined time. -1. It means that before the rollout start date, the `default` value is served to all users. +1. It means that before the rollout start date, the flag is considered disabled _(we serve the default value from the SDK)_. 2. Between the dates the flag is evaluated. -3. After the end date the `default` value is served to all users. +3. After the end date the flag is considered disabled. ## Example === "YAML" - ``` yaml linenums="1" hl_lines="6-10" + ``` yaml linenums="1" hl_lines="9-11" experimentation-flag: - percentage: 50 - true: "B" - false: "A" - default: "Default" - rollout: - experimentation: - start: 2021-03-20T00:00:00.10-05:00 - end: 2021-03-21T00:00:00.10-05:00 + variations: + variationA: A + variationB: B + defaultRule: + percentage: + variationA: 50 + variationB: 50 + experimentation: + start: 2021-03-20T00:00:00.1-05:00 + end: 2021-03-21T00:00:00.1-05:00 ``` === "JSON" - ``` json linenums="1" hl_lines="7-12" + ``` json linenums="1" hl_lines="13-16" { "experimentation-flag": { - "percentage": 50, - "true": "B", - "false": "A", - "default": "Default", - "rollout": { - "experimentation": { - "start": "2021-03-20 00:00:00 -0500", - "end": "2021-03-21 00:00:00 -0500" + "variations": { + "variationA": "A", + "variationB": "B" + }, + "defaultRule": { + "percentage": { + "variationA": 50, + "variationB": 50 } + }, + "experimentation": { + "start": "2021-03-20T05:00:00.100Z", + "end": "2021-03-21T05:00:00.100Z" } } } @@ -46,18 +52,18 @@ An **experimentation rollout** is when your flag is configured to be served only === "TOML" - ``` toml linenums="1" hl_lines="7-11" - [experimentation-flag] - percentage = 50.0 - true = "B" - false = "A" - default = "Default" + ``` toml linenums="1" hl_lines="9-11" + [experimentation-flag.variations] + variationA = "A" + variationB = "B" - [experimentation-flag.rollout] + [experimentation-flag.defaultRule.percentage] + variationA = 50 + variationB = 50 - [experimentation-flag.rollout.experimentation] - start = 2021-03-20T05:00:00.100Z - end = 2021-03-21T05:00:00.100Z + [experimentation-flag.experimentation] + start = 2021-03-20T05:00:00.100Z + end = 2021-03-21T05:00:00.100Z ``` Check this [example](https://github.com/thomaspoignant/go-feature-flag/tree/main/examples/rollout_scheduled) to see how it works. @@ -67,10 +73,10 @@ Check this [example](https://github.com/thomaspoignant/go-feature-flag/tree/main !!! Info The dates are in the format supported natively by your flag file format. -| Field | Description | -|---|---| -|**`start`**| The date the flag will be started to be served.| -|**`end`**| The date the flag will be stopped to be served.| +| Field | Description | +|-------------|-------------------------------------------------| +| **`start`** | The date the flag will be started to be served. | +| **`end`** | The date the flag will be stopped to be served. | ## A/B testing diff --git a/docs/rollout/index.md b/docs/rollout/index.md index 5be63f746b3..2cf21bdf19a 100644 --- a/docs/rollout/index.md +++ b/docs/rollout/index.md @@ -7,7 +7,7 @@ A critical part of every new feature release is orchestrating the actual launch Delivering powerful user experiences typically requires software teams to manage complex releases and make manual updates at inconvenient times. -But it doesn’t have to, having a complex **rollout** strategy allows you to have lifecycle for your flags. +But it does not have to, having a complex **rollout** strategy allows you to have lifecycle for your flags. ## Complex rollout strategy available diff --git a/docs/rollout/progressive.md b/docs/rollout/progressive.md index 0a56c50006a..a9622b7f1d0 100644 --- a/docs/rollout/progressive.md +++ b/docs/rollout/progressive.md @@ -13,38 +13,43 @@ and the end date. === "YAML" -``` yaml linenums="1" hl_lines="5-12" +``` yaml linenums="1" hl_lines="6-14" progressive-flag: - true: "B" - false: "A" - default: "Default" - rollout: - progressive: - percentage: - initial: 0 - end: 100 - releaseRamp: - start: 2021-03-20T00:00:00.10-05:00 - end: 2021-03-21T00:00:00.10-05:00 + variations: + variationA: A + variationB: B + defaultRule: + progressiveRollout: + initial: + variation: variationB + percentage: 0 + date: 2021-03-20T00:00:00.1-05:00 + end: + variation: variationB + percentage: 100 + date: 2021-03-21T00:00:00.1-05:00 ``` === "JSON" -``` json linenums="1" hl_lines="6-17" +``` json linenums="1" hl_lines="8-18" { "progressive-flag": { - "true": "B", - "false": "A", - "default": "Default", - "rollout": { - "progressive": { - "percentage": { - "initial": 0, - "end": 100 + "variations": { + "variationA": "A", + "variationB": "B" + }, + "defaultRule": { + "progressiveRollout": { + "initial": { + "variation": "variationB", + "percentage": 0, + "date": "2021-03-20T05:00:00.100Z" }, - "releaseRamp": { - "start": "2021-03-20T05:00:00.100Z", - "end": "2021-03-21T05:00:00.100Z" + "end": { + "variation": "variationB", + "percentage": 100, + "date": "2021-03-21T05:00:00.100Z" } } } @@ -54,23 +59,20 @@ progressive-flag: === "TOML" -``` toml linenums="1" hl_lines="6-16" -[progressive-flag] -true = "B" -false = "A" -default = "Default" +``` toml linenums="1" hl_lines="5-13" +[progressive-flag.variations] +variationA = "A" +variationB = "B" - [progressive-flag.rollout] +[progressive-flag.defaultRule.progressiveRollout.initial] +variation = "variationB" +percentage = 0 +date = 2021-03-20T05:00:00.100Z - [progressive-flag.rollout.progressive] - - [progressive-flag.rollout.progressive.percentage] - initial = 0.0 - end = 100.0 - - [progressive-flag.rollout.progressive.releaseRamp] - start = 2021-03-20T05:00:00.100Z - end = 2021-03-21T05:00:00.100Z +[progressive-flag.defaultRule.progressiveRollout.end] +variation = "variationB" +percentage = 100 +date = 2021-03-21T05:00:00.100Z ``` ## Configuration fields @@ -81,4 +83,4 @@ default = "Default" | Field | Description | |-------------------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------| | **`releaseRamp`** | It contains the time slot where we will progressively increase the percentage of the flag.
  • **Before** the `start` date we will serve the `percentage.initial` percentage of the flag.
  • **Between** `start` and `end` we will serve a percentage of the flag corresponding of the actual time.
  • **After** the `end` date we will serve the `percentage.end` percentage of the flag.

If you have no date in your `releaseRamp` we will not do any progressive rollout and use the top level percentage you have configured *(0% in our example)*.

| -| **`percentage`** | *(optional)*
It represents the ramp of progress, at which level the flag starts (`initial`) and at which level it ends (`end`).
**Default: `initial` = `0` and `end` = `100`** | +| **`percentage`** | *(optional)*
It represents the ramp of progress, at which level the flag starts (`initial`) and at which level it ends (`end`).
**Default: `initial` = `0` and `end` = `100`** | diff --git a/docs/rollout/scheduled.md b/docs/rollout/scheduled.md index 3daa45ad93f..b961beee60c 100644 --- a/docs/rollout/scheduled.md +++ b/docs/rollout/scheduled.md @@ -13,69 +13,106 @@ For example, you may want to turn a feature ON for internal testing tomorrow and === "YAML" -```yaml linenums="1" hl_lines="6-13" +```yaml linenums="1" hl_lines="10-22" scheduled-flag: - true: "B" - false: "A" - default: "Default" - rollout: - scheduled: - steps: - - date: 2020-04-10T00:00:00.10+02:00 - rule: beta eq "true" - percentage: 100 - - - date: 2022-05-12T15:36:00.10+02:00 - rule: beta eq "false" + variations: + variationA: A + variationB: B + defaultRule: + name: legacyDefaultRule + percentage: + variationA: 100 + variationB: 0 + scheduledRollout: + - date: 2020-04-10T00:00:00.1+02:00 + targeting: + - name: legacyRuleV0 + query: beta eq "true" + percentage: + variationA: 0 + variationB: 100 + + - date: 2022-05-12T15:36:00.1+02:00 + targeting: + - name: legacyRuleV0 + query: beta eq "false" ``` === "JSON" -```json linenums="1" hl_lines="6-19" +```json linenums="1" hl_lines="14-39" { "scheduled-flag": { - "true": "B", - "false": "A", - "default": "Default", - "rollout": { - "scheduled": { - "steps": [ + "variations": { + "variationA": "A", + "variationB": "B" + }, + "defaultRule": { + "name": "legacyDefaultRule", + "percentage": { + "variationA": 100, + "variationB": 0 + } + }, + "scheduledRollout": [ + { + "date": "2020-04-09T22:00:00.100Z", + "targeting": [ { - "date": "2020-04-09T22:00:00.100Z", - "rule": "beta eq \"true\"", - "percentage": 100 - }, + "name": "legacyRuleV0", + "query": "beta eq \"true\"", + "percentage": { + "variationA": 0, + "variationB": 100 + } + } + ] + }, + { + "date": "2022-05-12T13:36:00.100Z", + "targeting": [ { - "date": "2022-05-12T13:36:00.100Z", - "rule": "beta eq \"false\"" + "name": "legacyRuleV0", + "query": "beta eq \"false\"" } ] } - } + ] } } ``` === "TOML" -```toml linenums="1" hl_lines="6-17" -[scheduled-flag] -true = "B" -false = "A" -default = "Default" +```toml linenums="1" hl_lines="12-28" +[scheduled-flag.variations] +variationA = "A" +variationB = "B" + +[scheduled-flag.defaultRule] +name = "legacyDefaultRule" + + [scheduled-flag.defaultRule.percentage] + variationA = 100 + variationB = 0 + +[[scheduled-flag.scheduledRollout]] +date = 2020-04-09T22:00:00.100Z - [scheduled-flag.rollout] + [[scheduled-flag.scheduledRollout.targeting]] + name = "legacyRuleV0" + query = 'beta eq "true"' - [scheduled-flag.rollout.scheduled] + [scheduled-flag.scheduledRollout.targeting.percentage] + variationA = 0 + variationB = 100 - [[scheduled-flag.rollout.scheduled.steps]] - date = 2020-04-09T22:00:00.100Z - rule = "beta eq \"true\"" - percentage = 100.0 +[[scheduled-flag.scheduledRollout]] +date = 2022-05-12T13:36:00.100Z - [[scheduled-flag.rollout.scheduled.steps]] - date = 2022-05-12T13:36:00.100Z - rule = "beta eq \"false\"" + [[scheduled-flag.scheduledRollout.targeting]] + name = "legacyRuleV0" + query = 'beta eq "false"' ``` ## Configuration fields From a6e3c70edfc776dfe86d9ba3cbf5628c9bfccfc1 Mon Sep 17 00:00:00 2001 From: Thomas Poignant Date: Tue, 4 Oct 2022 09:03:03 +0200 Subject: [PATCH 39/50] Move rollout on top level Signed-off-by: Thomas Poignant --- cmd/migrationcli/converter.go | 35 +- cmd/migrationcli/test.yaml | 22 +- internal/dto/converter_test.go | 804 +++++++++++++++++---------------- internal/dto/dto.go | 8 +- internal/flag/internal_flag.go | 3 +- testdata/flag-config.json | 48 +- testdata/flag-config.toml | 40 +- testdata/flag-config.yaml | 36 +- 8 files changed, 543 insertions(+), 453 deletions(-) diff --git a/cmd/migrationcli/converter.go b/cmd/migrationcli/converter.go index fb4000195a0..6ae522b2f83 100644 --- a/cmd/migrationcli/converter.go +++ b/cmd/migrationcli/converter.go @@ -34,7 +34,8 @@ func (f *FlagConverter) Migrate() error { return err } - newFileContent, err := f.marshall(f.convert(flags)) + convertedFlag := f.convert(flags) + newFileContent, err := f.marshall(convertedFlag) if err != nil { return err } @@ -66,15 +67,16 @@ func (f *FlagConverter) unmarshall(content []byte) (map[string]dto.DTO, error) { return flags, nil } -func (f *FlagConverter) convert(flags map[string]dto.DTO) map[string]flag.InternalFlag { - convertedFlags := make(map[string]flag.InternalFlag, len(flags)) +func (f *FlagConverter) convert(flags map[string]dto.DTO) map[string]dto.DTO { + convertedFlags := make(map[string]dto.DTO, len(flags)) for k, v := range flags { - convertedFlags[k] = v.Convert() + // convert to internal Flag + convertedFlags[k] = convertToDto(v.Convert()) } return convertedFlags } -func (f *FlagConverter) marshall(convertedFlags map[string]flag.InternalFlag) ([]byte, error) { +func (f *FlagConverter) marshall(convertedFlags map[string]dto.DTO) ([]byte, error) { switch strings.ToLower(f.OutputFormat) { case "toml": buf := new(bytes.Buffer) @@ -95,3 +97,26 @@ func (f *FlagConverter) output(fileContent []byte) error { return os.WriteFile(f.OutputFile, fileContent, os.ModePerm) } + +func convertToDto(internalFlag flag.InternalFlag) dto.DTO { + var experimentation *dto.ExperimentationDto + if internalFlag.Experimentation != nil { + experimentation = &dto.ExperimentationDto{ + Start: internalFlag.Experimentation.Start, + End: internalFlag.Experimentation.End, + } + } + + return dto.DTO{ + TrackEvents: internalFlag.TrackEvents, + Disable: internalFlag.Disable, + Version: internalFlag.Version, + DTOv1: dto.DTOv1{ + Variations: internalFlag.Variations, + Rules: internalFlag.Rules, + DefaultRule: internalFlag.DefaultRule, + Scheduled: internalFlag.Scheduled, + Experimentation: experimentation, + }, + } +} diff --git a/cmd/migrationcli/test.yaml b/cmd/migrationcli/test.yaml index cec9396b60e..a6b63bc61d6 100644 --- a/cmd/migrationcli/test.yaml +++ b/cmd/migrationcli/test.yaml @@ -1,21 +1,13 @@ test-flag: - percentage: 100 rule: key eq "random-key" + percentage: 100 true: true false: false default: false - disable: false - trackEvents: true - version: 1 - rollout: - experimentation: - start: 2021-03-20T00:00:00.10-05:00 - end: 2021-03-21T00:00:00.10-05:00 - test-flag2: - rule: key eq "not-a-key" - percentage: 100 - true: true - false: false - default: false - version: 12 \ No newline at end of file +test-flag2: + rule: key eq "not-a-key" + percentage: 100 + true: true + false: false + default: false diff --git a/internal/dto/converter_test.go b/internal/dto/converter_test.go index 23756c05aa2..9615dc0a466 100644 --- a/internal/dto/converter_test.go +++ b/internal/dto/converter_test.go @@ -195,12 +195,12 @@ func TestConvertV0DtoToInternalFlag(t *testing.T) { True: testconvert.Interface("true"), False: testconvert.Interface("false"), Default: testconvert.Interface("default"), - }, - Rollout: &dto.Rollout{ - CommonRollout: dto.CommonRollout{ - Experimentation: &dto.ExperimentationDto{ - Start: testconvert.Time(time.Date(2021, time.February, 1, 10, 10, 10, 10, time.UTC)), - End: testconvert.Time(time.Date(2021, time.February, 2, 10, 10, 10, 10, time.UTC)), + Rollout: &dto.Rollout{ + CommonRollout: dto.CommonRollout{ + Experimentation: &dto.ExperimentationDto{ + Start: testconvert.Time(time.Date(2021, time.February, 1, 10, 10, 10, 10, time.UTC)), + End: testconvert.Time(time.Date(2021, time.February, 2, 10, 10, 10, 10, time.UTC)), + }, }, }, }, @@ -240,17 +240,17 @@ func TestConvertV0DtoToInternalFlag(t *testing.T) { True: testconvert.Interface("true"), False: testconvert.Interface("false"), Default: testconvert.Interface("default"), - }, - Rollout: &dto.Rollout{ - CommonRollout: dto.CommonRollout{ - Progressive: &dto.ProgressiveV0{ - Percentage: dto.ProgressivePercentageV0{ - Initial: 0, - End: 100, - }, - ReleaseRamp: dto.ProgressiveReleaseRampV0{ - Start: testconvert.Time(time.Date(2021, time.February, 1, 10, 10, 10, 10, time.UTC)), - End: testconvert.Time(time.Date(2021, time.February, 2, 10, 10, 10, 10, time.UTC)), + Rollout: &dto.Rollout{ + CommonRollout: dto.CommonRollout{ + Progressive: &dto.ProgressiveV0{ + Percentage: dto.ProgressivePercentageV0{ + Initial: 0, + End: 100, + }, + ReleaseRamp: dto.ProgressiveReleaseRampV0{ + Start: testconvert.Time(time.Date(2021, time.February, 1, 10, 10, 10, 10, time.UTC)), + End: testconvert.Time(time.Date(2021, time.February, 2, 10, 10, 10, 10, time.UTC)), + }, }, }, }, @@ -293,17 +293,17 @@ func TestConvertV0DtoToInternalFlag(t *testing.T) { True: testconvert.Interface("true"), False: testconvert.Interface("false"), Default: testconvert.Interface("default"), - }, - Rollout: &dto.Rollout{ - CommonRollout: dto.CommonRollout{ - Progressive: &dto.ProgressiveV0{ - Percentage: dto.ProgressivePercentageV0{ - Initial: 0, - End: 100, - }, - ReleaseRamp: dto.ProgressiveReleaseRampV0{ - Start: testconvert.Time(time.Date(2021, time.February, 1, 10, 10, 10, 10, time.UTC)), - End: testconvert.Time(time.Date(2021, time.February, 2, 10, 10, 10, 10, time.UTC)), + Rollout: &dto.Rollout{ + CommonRollout: dto.CommonRollout{ + Progressive: &dto.ProgressiveV0{ + Percentage: dto.ProgressivePercentageV0{ + Initial: 0, + End: 100, + }, + ReleaseRamp: dto.ProgressiveReleaseRampV0{ + Start: testconvert.Time(time.Date(2021, time.February, 1, 10, 10, 10, 10, time.UTC)), + End: testconvert.Time(time.Date(2021, time.February, 2, 10, 10, 10, 10, time.UTC)), + }, }, }, }, @@ -459,17 +459,17 @@ func TestConvertV0ScheduleStep(t *testing.T) { False: testconvert.Interface("false"), Default: testconvert.Interface("default"), Percentage: testconvert.Float64(95), - }, - Rollout: &dto.Rollout{ - V0Rollout: dto.V0Rollout{ - Scheduled: &dto.ScheduledRolloutV0{Steps: []dto.ScheduledStepV0{ - { - DTO: dto.DTO{DTOv0: dto.DTOv0{ - Rule: testconvert.String("anonymous eq false"), - }}, - Date: testconvert.Time(time.Now().Add(-2 * time.Second)), - }, - }}, + Rollout: &dto.Rollout{ + V0Rollout: dto.V0Rollout{ + Scheduled: &dto.ScheduledRolloutV0{Steps: []dto.ScheduledStepV0{ + { + DTO: dto.DTO{DTOv0: dto.DTOv0{ + Rule: testconvert.String("anonymous eq false"), + }}, + Date: testconvert.Time(time.Now().Add(-2 * time.Second)), + }, + }}, + }, }, }, }, @@ -483,18 +483,18 @@ func TestConvertV0ScheduleStep(t *testing.T) { False: testconvert.Interface("false"), Default: testconvert.Interface("default"), Percentage: testconvert.Float64(95), - }, - Rollout: &dto.Rollout{ - V0Rollout: dto.V0Rollout{ - Scheduled: &dto.ScheduledRolloutV0{Steps: []dto.ScheduledStepV0{ - { - DTO: dto.DTO{DTOv0: dto.DTOv0{ - Rule: testconvert.String("anonymous eq false"), - Percentage: testconvert.Float64(5), - }}, - Date: testconvert.Time(time.Now().Add(-2 * time.Second)), - }, - }}, + Rollout: &dto.Rollout{ + V0Rollout: dto.V0Rollout{ + Scheduled: &dto.ScheduledRolloutV0{Steps: []dto.ScheduledStepV0{ + { + DTO: dto.DTO{DTOv0: dto.DTOv0{ + Rule: testconvert.String("anonymous eq false"), + Percentage: testconvert.Float64(5), + }}, + Date: testconvert.Time(time.Now().Add(-2 * time.Second)), + }, + }}, + }, }, }, }, @@ -507,17 +507,17 @@ func TestConvertV0ScheduleStep(t *testing.T) { False: testconvert.Interface("false"), Default: testconvert.Interface("default"), Percentage: testconvert.Float64(100), - }, - Rollout: &dto.Rollout{ - V0Rollout: dto.V0Rollout{ - Scheduled: &dto.ScheduledRolloutV0{Steps: []dto.ScheduledStepV0{ - { - DTO: dto.DTO{DTOv0: dto.DTOv0{ - Percentage: testconvert.Float64(10), - }}, - Date: testconvert.Time(time.Now().Add(-2 * time.Second)), - }, - }}, + Rollout: &dto.Rollout{ + V0Rollout: dto.V0Rollout{ + Scheduled: &dto.ScheduledRolloutV0{Steps: []dto.ScheduledStepV0{ + { + DTO: dto.DTO{DTOv0: dto.DTOv0{ + Percentage: testconvert.Float64(10), + }}, + Date: testconvert.Time(time.Now().Add(-2 * time.Second)), + }, + }}, + }, }, }, }, @@ -530,17 +530,17 @@ func TestConvertV0ScheduleStep(t *testing.T) { False: testconvert.Interface("false"), Default: testconvert.Interface("default"), Percentage: testconvert.Float64(100), - }, - Rollout: &dto.Rollout{ - V0Rollout: dto.V0Rollout{ - Scheduled: &dto.ScheduledRolloutV0{Steps: []dto.ScheduledStepV0{ - { - DTO: dto.DTO{DTOv0: dto.DTOv0{ - Rule: testconvert.String("key eq \"ko\""), - }}, - Date: testconvert.Time(time.Now().Add(-2 * time.Second)), - }, - }}, + Rollout: &dto.Rollout{ + V0Rollout: dto.V0Rollout{ + Scheduled: &dto.ScheduledRolloutV0{Steps: []dto.ScheduledStepV0{ + { + DTO: dto.DTO{DTOv0: dto.DTOv0{ + Rule: testconvert.String("key eq \"ko\""), + }}, + Date: testconvert.Time(time.Now().Add(-2 * time.Second)), + }, + }}, + }, }, }, }, @@ -553,17 +553,17 @@ func TestConvertV0ScheduleStep(t *testing.T) { False: testconvert.Interface("false"), Default: testconvert.Interface("default"), Percentage: testconvert.Float64(100), - }, - Rollout: &dto.Rollout{ - V0Rollout: dto.V0Rollout{ - Scheduled: &dto.ScheduledRolloutV0{Steps: []dto.ScheduledStepV0{ - { - DTO: dto.DTO{DTOv0: dto.DTOv0{ - Rule: testconvert.String("key eq \"yo\""), - }}, - Date: testconvert.Time(time.Now().Add(-2 * time.Second)), - }, - }}, + Rollout: &dto.Rollout{ + V0Rollout: dto.V0Rollout{ + Scheduled: &dto.ScheduledRolloutV0{Steps: []dto.ScheduledStepV0{ + { + DTO: dto.DTO{DTOv0: dto.DTOv0{ + Rule: testconvert.String("key eq \"yo\""), + }}, + Date: testconvert.Time(time.Now().Add(-2 * time.Second)), + }, + }}, + }, }, }, }, @@ -576,17 +576,17 @@ func TestConvertV0ScheduleStep(t *testing.T) { False: testconvert.Interface("false"), Default: testconvert.Interface("default"), Percentage: testconvert.Float64(100), - }, - Rollout: &dto.Rollout{ - V0Rollout: dto.V0Rollout{ - Scheduled: &dto.ScheduledRolloutV0{Steps: []dto.ScheduledStepV0{ - { - DTO: dto.DTO{DTOv0: dto.DTOv0{ - True: testconvert.Interface("newValue"), - }}, - Date: testconvert.Time(time.Now().Add(-2 * time.Second)), - }, - }}, + Rollout: &dto.Rollout{ + V0Rollout: dto.V0Rollout{ + Scheduled: &dto.ScheduledRolloutV0{Steps: []dto.ScheduledStepV0{ + { + DTO: dto.DTO{DTOv0: dto.DTOv0{ + True: testconvert.Interface("newValue"), + }}, + Date: testconvert.Time(time.Now().Add(-2 * time.Second)), + }, + }}, + }, }, }, }, @@ -599,17 +599,17 @@ func TestConvertV0ScheduleStep(t *testing.T) { False: testconvert.Interface("false"), Default: testconvert.Interface("default"), Percentage: testconvert.Float64(100), - }, - Rollout: &dto.Rollout{ - V0Rollout: dto.V0Rollout{ - Scheduled: &dto.ScheduledRolloutV0{Steps: []dto.ScheduledStepV0{ - { - DTO: dto.DTO{DTOv0: dto.DTOv0{ - Percentage: testconvert.Float64(10), - }}, - Date: testconvert.Time(time.Now().Add(-2 * time.Second)), - }, - }}, + Rollout: &dto.Rollout{ + V0Rollout: dto.V0Rollout{ + Scheduled: &dto.ScheduledRolloutV0{Steps: []dto.ScheduledStepV0{ + { + DTO: dto.DTO{DTOv0: dto.DTOv0{ + Percentage: testconvert.Float64(10), + }}, + Date: testconvert.Time(time.Now().Add(-2 * time.Second)), + }, + }}, + }, }, }, }, @@ -622,18 +622,18 @@ func TestConvertV0ScheduleStep(t *testing.T) { False: testconvert.Interface("false"), Default: testconvert.Interface("default"), Percentage: testconvert.Float64(100), - }, - Rollout: &dto.Rollout{ - V0Rollout: dto.V0Rollout{ - Scheduled: &dto.ScheduledRolloutV0{Steps: []dto.ScheduledStepV0{ - { - DTO: dto.DTO{DTOv0: dto.DTOv0{ - Rule: testconvert.String("key eq \"yo\""), - Percentage: testconvert.Float64(10), - }}, - Date: testconvert.Time(time.Now().Add(-2 * time.Second)), - }, - }}, + Rollout: &dto.Rollout{ + V0Rollout: dto.V0Rollout{ + Scheduled: &dto.ScheduledRolloutV0{Steps: []dto.ScheduledStepV0{ + { + DTO: dto.DTO{DTOv0: dto.DTOv0{ + Rule: testconvert.String("key eq \"yo\""), + Percentage: testconvert.Float64(10), + }}, + Date: testconvert.Time(time.Now().Add(-2 * time.Second)), + }, + }}, + }, }, }, }, @@ -646,18 +646,18 @@ func TestConvertV0ScheduleStep(t *testing.T) { False: testconvert.Interface("false"), Default: testconvert.Interface("default"), Percentage: testconvert.Float64(100), - }, - Rollout: &dto.Rollout{ - V0Rollout: dto.V0Rollout{ - Scheduled: &dto.ScheduledRolloutV0{Steps: []dto.ScheduledStepV0{ - { - DTO: dto.DTO{DTOv0: dto.DTOv0{ - Rule: testconvert.String("key eq \"yo\""), - Percentage: testconvert.Float64(50), - }}, - Date: testconvert.Time(time.Now().Add(-2 * time.Second)), - }, - }}, + Rollout: &dto.Rollout{ + V0Rollout: dto.V0Rollout{ + Scheduled: &dto.ScheduledRolloutV0{Steps: []dto.ScheduledStepV0{ + { + DTO: dto.DTO{DTOv0: dto.DTOv0{ + Rule: testconvert.String("key eq \"yo\""), + Percentage: testconvert.Float64(50), + }}, + Date: testconvert.Time(time.Now().Add(-2 * time.Second)), + }, + }}, + }, }, }, }, @@ -671,29 +671,29 @@ func TestConvertV0ScheduleStep(t *testing.T) { Default: testconvert.Interface("default"), Rule: testconvert.String("key eq \"yo\""), Percentage: testconvert.Float64(100), - }, - Rollout: &dto.Rollout{ - V0Rollout: dto.V0Rollout{ - Scheduled: &dto.ScheduledRolloutV0{Steps: []dto.ScheduledStepV0{ - { - DTO: dto.DTO{DTOv0: dto.DTOv0{ - Rule: testconvert.String("key eq \"yo\""), - }}, - Date: testconvert.Time(time.Now().Add(-2 * time.Second)), - }, - { - DTO: dto.DTO{DTOv0: dto.DTOv0{ - Rule: testconvert.String(""), - }}, - Date: testconvert.Time(time.Now().Add(-2 * time.Second)), - }, - { - DTO: dto.DTO{DTOv0: dto.DTOv0{ - Percentage: testconvert.Float64(10), - }}, - Date: testconvert.Time(time.Now().Add(-2 * time.Second)), - }, - }}, + Rollout: &dto.Rollout{ + V0Rollout: dto.V0Rollout{ + Scheduled: &dto.ScheduledRolloutV0{Steps: []dto.ScheduledStepV0{ + { + DTO: dto.DTO{DTOv0: dto.DTOv0{ + Rule: testconvert.String("key eq \"yo\""), + }}, + Date: testconvert.Time(time.Now().Add(-2 * time.Second)), + }, + { + DTO: dto.DTO{DTOv0: dto.DTOv0{ + Rule: testconvert.String(""), + }}, + Date: testconvert.Time(time.Now().Add(-2 * time.Second)), + }, + { + DTO: dto.DTO{DTOv0: dto.DTOv0{ + Percentage: testconvert.Float64(10), + }}, + Date: testconvert.Time(time.Now().Add(-2 * time.Second)), + }, + }}, + }, }, }, }, @@ -707,17 +707,17 @@ func TestConvertV0ScheduleStep(t *testing.T) { Default: testconvert.Interface("default"), Rule: testconvert.String("key eq \"yo\""), Percentage: testconvert.Float64(95), - }, - Rollout: &dto.Rollout{ - V0Rollout: dto.V0Rollout{ - Scheduled: &dto.ScheduledRolloutV0{Steps: []dto.ScheduledStepV0{ - { - DTO: dto.DTO{DTOv0: dto.DTOv0{ - Rule: testconvert.String(""), - }}, - Date: testconvert.Time(time.Now().Add(-2 * time.Second)), - }, - }}, + Rollout: &dto.Rollout{ + V0Rollout: dto.V0Rollout{ + Scheduled: &dto.ScheduledRolloutV0{Steps: []dto.ScheduledStepV0{ + { + DTO: dto.DTO{DTOv0: dto.DTOv0{ + Rule: testconvert.String(""), + }}, + Date: testconvert.Time(time.Now().Add(-2 * time.Second)), + }, + }}, + }, }, }, }, @@ -731,17 +731,17 @@ func TestConvertV0ScheduleStep(t *testing.T) { Default: testconvert.Interface("default"), Rule: testconvert.String("key eq \"yo\""), Percentage: testconvert.Float64(95), - }, - Rollout: &dto.Rollout{ - V0Rollout: dto.V0Rollout{ - Scheduled: &dto.ScheduledRolloutV0{Steps: []dto.ScheduledStepV0{ - { - DTO: dto.DTO{DTOv0: dto.DTOv0{ - Rule: testconvert.String(""), - }}, - Date: testconvert.Time(time.Now().Add(-2 * time.Second)), - }, - }}, + Rollout: &dto.Rollout{ + V0Rollout: dto.V0Rollout{ + Scheduled: &dto.ScheduledRolloutV0{Steps: []dto.ScheduledStepV0{ + { + DTO: dto.DTO{DTOv0: dto.DTOv0{ + Rule: testconvert.String(""), + }}, + Date: testconvert.Time(time.Now().Add(-2 * time.Second)), + }, + }}, + }, }, }, }, @@ -755,30 +755,32 @@ func TestConvertV0ScheduleStep(t *testing.T) { Default: testconvert.Interface("default"), Rule: testconvert.String("key eq \"yo\""), Percentage: testconvert.Float64(0), - }, - Rollout: &dto.Rollout{ - V0Rollout: dto.V0Rollout{ - Scheduled: &dto.ScheduledRolloutV0{Steps: []dto.ScheduledStepV0{ - { - DTO: dto.DTO{ - Rollout: &dto.Rollout{ - CommonRollout: dto.CommonRollout{ - Progressive: &dto.ProgressiveV0{ - Percentage: dto.ProgressivePercentageV0{ - Initial: 0, - End: 100, - }, - ReleaseRamp: dto.ProgressiveReleaseRampV0{ - Start: testconvert.Time(time.Now().Add(-300 * time.Second)), - End: testconvert.Time(time.Now().Add(-1 * time.Second)), + Rollout: &dto.Rollout{ + V0Rollout: dto.V0Rollout{ + Scheduled: &dto.ScheduledRolloutV0{Steps: []dto.ScheduledStepV0{ + { + DTO: dto.DTO{ + DTOv0: dto.DTOv0{ + Rollout: &dto.Rollout{ + CommonRollout: dto.CommonRollout{ + Progressive: &dto.ProgressiveV0{ + Percentage: dto.ProgressivePercentageV0{ + Initial: 0, + End: 100, + }, + ReleaseRamp: dto.ProgressiveReleaseRampV0{ + Start: testconvert.Time(time.Now().Add(-300 * time.Second)), + End: testconvert.Time(time.Now().Add(-1 * time.Second)), + }, + }, }, }, }, }, + Date: testconvert.Time(time.Now().Add(-2 * time.Second)), }, - Date: testconvert.Time(time.Now().Add(-2 * time.Second)), - }, - }}, + }}, + }, }, }, }, @@ -792,30 +794,32 @@ func TestConvertV0ScheduleStep(t *testing.T) { Default: testconvert.Interface("default"), Rule: testconvert.String("key eq \"yo\""), Percentage: testconvert.Float64(0), - }, - Rollout: &dto.Rollout{ - V0Rollout: dto.V0Rollout{ - Scheduled: &dto.ScheduledRolloutV0{Steps: []dto.ScheduledStepV0{ - { - DTO: dto.DTO{ - Rollout: &dto.Rollout{ - CommonRollout: dto.CommonRollout{ - Progressive: &dto.ProgressiveV0{ - Percentage: dto.ProgressivePercentageV0{ - Initial: 0, - End: 100, - }, - ReleaseRamp: dto.ProgressiveReleaseRampV0{ - Start: testconvert.Time(time.Now().Add(-1 * time.Second)), - End: testconvert.Time(time.Now().Add(600 * time.Second)), + Rollout: &dto.Rollout{ + V0Rollout: dto.V0Rollout{ + Scheduled: &dto.ScheduledRolloutV0{Steps: []dto.ScheduledStepV0{ + { + DTO: dto.DTO{ + DTOv0: dto.DTOv0{ + Rollout: &dto.Rollout{ + CommonRollout: dto.CommonRollout{ + Progressive: &dto.ProgressiveV0{ + Percentage: dto.ProgressivePercentageV0{ + Initial: 0, + End: 100, + }, + ReleaseRamp: dto.ProgressiveReleaseRampV0{ + Start: testconvert.Time(time.Now().Add(-1 * time.Second)), + End: testconvert.Time(time.Now().Add(600 * time.Second)), + }, + }, }, }, }, }, + Date: testconvert.Time(time.Now().Add(-2 * time.Second)), }, - Date: testconvert.Time(time.Now().Add(-2 * time.Second)), - }, - }}, + }}, + }, }, }, }, @@ -829,27 +833,27 @@ func TestConvertV0ScheduleStep(t *testing.T) { Default: testconvert.Interface("default"), Rule: testconvert.String("key eq \"yo\""), Percentage: testconvert.Float64(0), - }, - Rollout: &dto.Rollout{ - V0Rollout: dto.V0Rollout{ - Scheduled: &dto.ScheduledRolloutV0{Steps: []dto.ScheduledStepV0{ - { - DTO: dto.DTO{ - DTOv0: dto.DTOv0{ - Percentage: testconvert.Float64(100), - }, - Rollout: &dto.Rollout{ - CommonRollout: dto.CommonRollout{ - Experimentation: &dto.ExperimentationDto{ - Start: testconvert.Time(time.Now().Add(-1 * time.Second)), - End: testconvert.Time(time.Now().Add(600 * time.Second)), + Rollout: &dto.Rollout{ + V0Rollout: dto.V0Rollout{ + Scheduled: &dto.ScheduledRolloutV0{Steps: []dto.ScheduledStepV0{ + { + DTO: dto.DTO{ + DTOv0: dto.DTOv0{ + Percentage: testconvert.Float64(100), + Rollout: &dto.Rollout{ + CommonRollout: dto.CommonRollout{ + Experimentation: &dto.ExperimentationDto{ + Start: testconvert.Time(time.Now().Add(-1 * time.Second)), + End: testconvert.Time(time.Now().Add(600 * time.Second)), + }, + }, }, }, }, + Date: testconvert.Time(time.Now().Add(-2 * time.Second)), }, - Date: testconvert.Time(time.Now().Add(-2 * time.Second)), - }, - }}, + }}, + }, }, }, }, @@ -863,83 +867,87 @@ func TestConvertV0ScheduleStep(t *testing.T) { Default: testconvert.Interface("default"), Rule: testconvert.String("key eq \"yo\""), Percentage: testconvert.Float64(100), - }, - Rollout: &dto.Rollout{ - V0Rollout: dto.V0Rollout{ - Scheduled: &dto.ScheduledRolloutV0{Steps: []dto.ScheduledStepV0{ - { - DTO: dto.DTO{DTOv0: dto.DTOv0{ - Percentage: testconvert.Float64(10), - }}, - Date: testconvert.Time(time.Now().Add(-2 * time.Second)), - }, - { - DTO: dto.DTO{DTOv0: dto.DTOv0{ - Rule: testconvert.String("key eq \"yo\""), - }}, - Date: testconvert.Time(time.Now().Add(-2 * time.Second)), - }, - { - DTO: dto.DTO{DTOv0: dto.DTOv0{ - True: testconvert.Interface("newValue"), - }}, - Date: testconvert.Time(time.Now().Add(-2 * time.Second)), - }, - { - DTO: dto.DTO{DTOv0: dto.DTOv0{ - Percentage: testconvert.Float64(10), - }}, - Date: testconvert.Time(time.Now().Add(-2 * time.Second)), - }, - { - DTO: dto.DTO{DTOv0: dto.DTOv0{ - Rule: testconvert.String(""), - Percentage: testconvert.Float64(100), - }}, - Date: testconvert.Time(time.Now().Add(-2 * time.Second)), - }, - { - DTO: dto.DTO{ - Disable: testconvert.Bool(true), + Rollout: &dto.Rollout{ + V0Rollout: dto.V0Rollout{ + Scheduled: &dto.ScheduledRolloutV0{Steps: []dto.ScheduledStepV0{ + { + DTO: dto.DTO{DTOv0: dto.DTOv0{ + Percentage: testconvert.Float64(10), + }}, + Date: testconvert.Time(time.Now().Add(-2 * time.Second)), }, - Date: testconvert.Time(time.Now().Add(-2 * time.Second)), - }, - { - DTO: dto.DTO{ - Disable: testconvert.Bool(false), - DTOv0: dto.DTOv0{ - Rule: testconvert.String("anonymous eq false"), + { + DTO: dto.DTO{DTOv0: dto.DTOv0{ + Rule: testconvert.String("key eq \"yo\""), + }}, + Date: testconvert.Time(time.Now().Add(-2 * time.Second)), + }, + { + DTO: dto.DTO{DTOv0: dto.DTOv0{ + True: testconvert.Interface("newValue"), + }}, + Date: testconvert.Time(time.Now().Add(-2 * time.Second)), + }, + { + DTO: dto.DTO{DTOv0: dto.DTOv0{ + Percentage: testconvert.Float64(10), + }}, + Date: testconvert.Time(time.Now().Add(-2 * time.Second)), + }, + { + DTO: dto.DTO{DTOv0: dto.DTOv0{ + Rule: testconvert.String(""), Percentage: testconvert.Float64(100), + }}, + Date: testconvert.Time(time.Now().Add(-2 * time.Second)), + }, + { + DTO: dto.DTO{ + Disable: testconvert.Bool(true), }, + Date: testconvert.Time(time.Now().Add(-2 * time.Second)), }, - Date: testconvert.Time(time.Now().Add(-2 * time.Second)), - }, - { - DTO: dto.DTO{ - Rollout: &dto.Rollout{ - CommonRollout: dto.CommonRollout{ - Experimentation: &dto.ExperimentationDto{ - Start: testconvert.Time(time.Now().Add(-2 * time.Second)), - End: testconvert.Time(time.Now().Add(2 * time.Second)), + { + DTO: dto.DTO{ + Disable: testconvert.Bool(false), + DTOv0: dto.DTOv0{ + Rule: testconvert.String("anonymous eq false"), + Percentage: testconvert.Float64(100), + }, + }, + Date: testconvert.Time(time.Now().Add(-2 * time.Second)), + }, + { + DTO: dto.DTO{ + DTOv0: dto.DTOv0{ + Rollout: &dto.Rollout{ + CommonRollout: dto.CommonRollout{ + Experimentation: &dto.ExperimentationDto{ + Start: testconvert.Time(time.Now().Add(-2 * time.Second)), + End: testconvert.Time(time.Now().Add(2 * time.Second)), + }, + }, }, }, }, + Date: testconvert.Time(time.Now().Add(-2 * time.Second)), }, - Date: testconvert.Time(time.Now().Add(-2 * time.Second)), - }, - { - DTO: dto.DTO{ - Rollout: &dto.Rollout{ - CommonRollout: dto.CommonRollout{ - Experimentation: &dto.ExperimentationDto{ - End: testconvert.Time(time.Now().Add(-2 * time.Second)), + { + DTO: dto.DTO{ + DTOv0: dto.DTOv0{ + Rollout: &dto.Rollout{ + CommonRollout: dto.CommonRollout{ + Experimentation: &dto.ExperimentationDto{ + End: testconvert.Time(time.Now().Add(-2 * time.Second)), + }, + }, }, }, }, + Date: testconvert.Time(time.Now().Add(-2 * time.Second)), }, - Date: testconvert.Time(time.Now().Add(-2 * time.Second)), - }, - }}, + }}, + }, }, }, }, @@ -952,18 +960,18 @@ func TestConvertV0ScheduleStep(t *testing.T) { False: testconvert.Interface("false"), Default: testconvert.Interface("default"), Percentage: testconvert.Float64(100), - }, - Rollout: &dto.Rollout{ - V0Rollout: dto.V0Rollout{ - Scheduled: &dto.ScheduledRolloutV0{Steps: []dto.ScheduledStepV0{ - { - DTO: dto.DTO{DTOv0: dto.DTOv0{ - Rule: testconvert.String(""), - Percentage: testconvert.Float64(95), - }}, - Date: testconvert.Time(time.Now().Add(-2 * time.Second)), - }, - }}, + Rollout: &dto.Rollout{ + V0Rollout: dto.V0Rollout{ + Scheduled: &dto.ScheduledRolloutV0{Steps: []dto.ScheduledStepV0{ + { + DTO: dto.DTO{DTOv0: dto.DTOv0{ + Rule: testconvert.String(""), + Percentage: testconvert.Float64(95), + }}, + Date: testconvert.Time(time.Now().Add(-2 * time.Second)), + }, + }}, + }, }, }, }, @@ -975,30 +983,32 @@ func TestConvertV0ScheduleStep(t *testing.T) { True: testconvert.Interface("true"), False: testconvert.Interface("false"), Default: testconvert.Interface("default"), - }, - Rollout: &dto.Rollout{ - V0Rollout: dto.V0Rollout{ - Scheduled: &dto.ScheduledRolloutV0{Steps: []dto.ScheduledStepV0{ - { - DTO: dto.DTO{ - Rollout: &dto.Rollout{ - CommonRollout: dto.CommonRollout{ - Progressive: &dto.ProgressiveV0{ - Percentage: dto.ProgressivePercentageV0{ - Initial: 0, - End: 100, - }, - ReleaseRamp: dto.ProgressiveReleaseRampV0{ - Start: testconvert.Time(time.Now().Add(10 * time.Minute)), - End: testconvert.Time(time.Now().Add(20 * time.Minute)), + Rollout: &dto.Rollout{ + V0Rollout: dto.V0Rollout{ + Scheduled: &dto.ScheduledRolloutV0{Steps: []dto.ScheduledStepV0{ + { + DTO: dto.DTO{ + DTOv0: dto.DTOv0{ + Rollout: &dto.Rollout{ + CommonRollout: dto.CommonRollout{ + Progressive: &dto.ProgressiveV0{ + Percentage: dto.ProgressivePercentageV0{ + Initial: 0, + End: 100, + }, + ReleaseRamp: dto.ProgressiveReleaseRampV0{ + Start: testconvert.Time(time.Now().Add(10 * time.Minute)), + End: testconvert.Time(time.Now().Add(20 * time.Minute)), + }, + }, }, }, }, }, + Date: testconvert.Time(time.Now().Add(-2 * time.Second)), }, - Date: testconvert.Time(time.Now().Add(-2 * time.Second)), - }, - }}, + }}, + }, }, }, }, @@ -1011,35 +1021,35 @@ func TestConvertV0ScheduleStep(t *testing.T) { False: testconvert.Interface("false"), Default: testconvert.Interface("default"), Rule: testconvert.String("key eq \"yo\""), - }, - Rollout: &dto.Rollout{ - V0Rollout: dto.V0Rollout{ - Scheduled: &dto.ScheduledRolloutV0{Steps: []dto.ScheduledStepV0{ - { - DTO: dto.DTO{ - TrackEvents: testconvert.Bool(true), - Version: testconvert.String("1.0.1"), - DTOv0: dto.DTOv0{ - Rule: testconvert.String("anonymous eq false"), - }, - Rollout: &dto.Rollout{ - CommonRollout: dto.CommonRollout{ - Progressive: &dto.ProgressiveV0{ - Percentage: dto.ProgressivePercentageV0{ - Initial: 0, - End: 100, - }, - ReleaseRamp: dto.ProgressiveReleaseRampV0{ - Start: testconvert.Time(time.Now().Add(-10 * time.Minute)), - End: testconvert.Time(time.Now().Add(0 * time.Minute)), + Rollout: &dto.Rollout{ + V0Rollout: dto.V0Rollout{ + Scheduled: &dto.ScheduledRolloutV0{Steps: []dto.ScheduledStepV0{ + { + DTO: dto.DTO{ + TrackEvents: testconvert.Bool(true), + Version: testconvert.String("1.0.1"), + DTOv0: dto.DTOv0{ + Rule: testconvert.String("anonymous eq false"), + Rollout: &dto.Rollout{ + CommonRollout: dto.CommonRollout{ + Progressive: &dto.ProgressiveV0{ + Percentage: dto.ProgressivePercentageV0{ + Initial: 0, + End: 100, + }, + ReleaseRamp: dto.ProgressiveReleaseRampV0{ + Start: testconvert.Time(time.Now().Add(-10 * time.Minute)), + End: testconvert.Time(time.Now().Add(0 * time.Minute)), + }, + }, }, }, }, }, + Date: testconvert.Time(time.Now().Add(-2 * time.Second)), }, - Date: testconvert.Time(time.Now().Add(-2 * time.Second)), - }, - }}, + }}, + }, }, }, }, @@ -1051,35 +1061,35 @@ func TestConvertV0ScheduleStep(t *testing.T) { True: testconvert.Interface("true"), False: testconvert.Interface("false"), Default: testconvert.Interface("default"), - }, - Rollout: &dto.Rollout{ - V0Rollout: dto.V0Rollout{ - Scheduled: &dto.ScheduledRolloutV0{Steps: []dto.ScheduledStepV0{ - { - DTO: dto.DTO{ - TrackEvents: testconvert.Bool(true), - Version: testconvert.String("1.0.1"), - DTOv0: dto.DTOv0{ - Rule: testconvert.String("anonymous eq false"), - }, - Rollout: &dto.Rollout{ - CommonRollout: dto.CommonRollout{ - Progressive: &dto.ProgressiveV0{ - Percentage: dto.ProgressivePercentageV0{ - Initial: 0, - End: 100, - }, - ReleaseRamp: dto.ProgressiveReleaseRampV0{ - Start: testconvert.Time(time.Now().Add(-10 * time.Minute)), - End: testconvert.Time(time.Now().Add(0 * time.Minute)), + Rollout: &dto.Rollout{ + V0Rollout: dto.V0Rollout{ + Scheduled: &dto.ScheduledRolloutV0{Steps: []dto.ScheduledStepV0{ + { + DTO: dto.DTO{ + TrackEvents: testconvert.Bool(true), + Version: testconvert.String("1.0.1"), + DTOv0: dto.DTOv0{ + Rule: testconvert.String("anonymous eq false"), + Rollout: &dto.Rollout{ + CommonRollout: dto.CommonRollout{ + Progressive: &dto.ProgressiveV0{ + Percentage: dto.ProgressivePercentageV0{ + Initial: 0, + End: 100, + }, + ReleaseRamp: dto.ProgressiveReleaseRampV0{ + Start: testconvert.Time(time.Now().Add(-10 * time.Minute)), + End: testconvert.Time(time.Now().Add(0 * time.Minute)), + }, + }, }, }, }, }, + Date: testconvert.Time(time.Now().Add(-2 * time.Second)), }, - Date: testconvert.Time(time.Now().Add(-2 * time.Second)), - }, - }}, + }}, + }, }, }, }, @@ -1091,34 +1101,34 @@ func TestConvertV0ScheduleStep(t *testing.T) { True: testconvert.Interface("true"), False: testconvert.Interface("false"), Default: testconvert.Interface("default"), - }, - Rollout: &dto.Rollout{ - V0Rollout: dto.V0Rollout{ - Scheduled: &dto.ScheduledRolloutV0{ - Steps: []dto.ScheduledStepV0{ - { - DTO: dto.DTO{ - TrackEvents: testconvert.Bool(true), - Version: testconvert.String("1.0.1"), - DTOv0: dto.DTOv0{ - Rule: testconvert.String(""), - }, - Rollout: &dto.Rollout{ - CommonRollout: dto.CommonRollout{ - Progressive: &dto.ProgressiveV0{ - Percentage: dto.ProgressivePercentageV0{ - Initial: 0, - End: 100, - }, - ReleaseRamp: dto.ProgressiveReleaseRampV0{ - Start: testconvert.Time(time.Now().Add(-10 * time.Minute)), - End: testconvert.Time(time.Now().Add(0 * time.Minute)), + Rollout: &dto.Rollout{ + V0Rollout: dto.V0Rollout{ + Scheduled: &dto.ScheduledRolloutV0{ + Steps: []dto.ScheduledStepV0{ + { + DTO: dto.DTO{ + TrackEvents: testconvert.Bool(true), + Version: testconvert.String("1.0.1"), + DTOv0: dto.DTOv0{ + Rule: testconvert.String(""), + Rollout: &dto.Rollout{ + CommonRollout: dto.CommonRollout{ + Progressive: &dto.ProgressiveV0{ + Percentage: dto.ProgressivePercentageV0{ + Initial: 0, + End: 100, + }, + ReleaseRamp: dto.ProgressiveReleaseRampV0{ + Start: testconvert.Time(time.Now().Add(-10 * time.Minute)), + End: testconvert.Time(time.Now().Add(0 * time.Minute)), + }, + }, }, }, }, }, + Date: testconvert.Time(time.Now().Add(-2 * time.Second)), }, - Date: testconvert.Time(time.Now().Add(-2 * time.Second)), }, }, }, diff --git a/internal/dto/dto.go b/internal/dto/dto.go index 4336ecb47fc..51dc49b4f5a 100644 --- a/internal/dto/dto.go +++ b/internal/dto/dto.go @@ -25,10 +25,6 @@ type DTO struct { // Converter (optional) is the name of converter to use, if no converter specified we try to determine // which converter to use based on the fields we receive for the flag Converter *string `json:"converter,omitempty" yaml:"converter,omitempty" toml:"converter,omitempty"` - - // Rollout is the object to configure how the flag is rolled out. - // You have different rollout strategy available but only one is used at a time. - Rollout *Rollout `json:"rollout,omitempty" yaml:"rollout,omitempty" toml:"rollout,omitempty"` } // DTOv1 is the new format of the flags since version 1.X.X @@ -77,6 +73,10 @@ type DTOv0 struct { // Default is the value return by the flag if not apply to the user (rule is evaluated to false). Default *interface{} `json:"default,omitempty" yaml:"default,omitempty" toml:"default,omitempty"` + + // Rollout is the object to configure how the flag is rolled out. + // You have different rollout strategy available but only one is used at a time. + Rollout *Rollout `json:"rollout,omitempty" yaml:"rollout,omitempty" toml:"rollout,omitempty"` } func (d *DTO) Convert() flag.InternalFlag { diff --git a/internal/flag/internal_flag.go b/internal/flag/internal_flag.go index 47b19e1c9e4..2bde5851abf 100644 --- a/internal/flag/internal_flag.go +++ b/internal/flag/internal_flag.go @@ -18,8 +18,7 @@ const ( // All the flags in your configuration files can have different format but will be // converted into an InternalFlag to be used in the library. type InternalFlag struct { - // Variations are all the variations available for this flag. The minimum is 2 variations and, we don't have any max - // limit except if the variationValue is a bool, the max is 2. + // Variations are all the variations available for this flag. You can have as many variation as needed. Variations *map[string]*interface{} `json:"variations,omitempty" yaml:"variations,omitempty" toml:"variations,omitempty"` // nolint:lll // Rules is the list of Rule for this flag. diff --git a/testdata/flag-config.json b/testdata/flag-config.json index 98fd2943882..464ce6b55fa 100644 --- a/testdata/flag-config.json +++ b/testdata/flag-config.json @@ -1,16 +1,44 @@ { "test-flag": { - "rule": "key eq \"random-key\"", - "percentage": 100, - "true": true, - "false": false, - "default": false + "variations": { + "Default": false, + "false": false, + "true": true + }, + "targeting": [ + { + "name": "legacyRuleV0", + "query": "key eq \"random-key\"", + "percentage": { + "false": 0, + "true": 100 + } + } + ], + "defaultRule": { + "name": "legacyDefaultRule", + "variation": "Default" + } }, "test-flag2": { - "rule": "key eq \"not-a-key\"", - "percentage": 100, - "true": true, - "false": false, - "default": false + "variations": { + "Default": false, + "false": false, + "true": true + }, + "targeting": [ + { + "name": "legacyRuleV0", + "query": "key eq \"not-a-key\"", + "percentage": { + "false": 0, + "true": 100 + } + } + ], + "defaultRule": { + "name": "legacyDefaultRule", + "variation": "Default" + } } } diff --git a/testdata/flag-config.toml b/testdata/flag-config.toml index 4a82ef51d41..58516e52521 100644 --- a/testdata/flag-config.toml +++ b/testdata/flag-config.toml @@ -1,13 +1,33 @@ -[test-flag] -rule = "key eq \"random-key\"" -percentage = 100.0 -true = true +[test-flag.variations] +Default = false false = false -default = false - -[test-flag2] -rule = "key eq \"not-a-key\"" -percentage = 100.0 true = true + +[[test-flag.targeting]] +name = "legacyRuleV0" +query = 'key eq "random-key"' + +[test-flag.targeting.percentage] +false = 0.0 +true = 100.0 + +[test-flag.defaultRule] +name = "legacyDefaultRule" +variation = "Default" + +[test-flag2.variations] +Default = false false = false -default = false +true = true + +[[test-flag2.targeting]] +name = "legacyRuleV0" +query = 'key eq "not-a-key"' + +[test-flag2.targeting.percentage] +false = 0.0 +true = 100.0 + +[test-flag2.defaultRule] +name = "legacyDefaultRule" +variation = "Default" diff --git a/testdata/flag-config.yaml b/testdata/flag-config.yaml index a6b63bc61d6..01aded5be1a 100644 --- a/testdata/flag-config.yaml +++ b/testdata/flag-config.yaml @@ -1,13 +1,29 @@ test-flag: - rule: key eq "random-key" - percentage: 100 - true: true - false: false - default: false + variations: + Default: false + False: false + True: true + targeting: + - name: legacyRuleV0 + query: key eq "random-key" + percentage: + False: 0 + True: 100 + defaultRule: + name: legacyDefaultRule + variation: Default test-flag2: - rule: key eq "not-a-key" - percentage: 100 - true: true - false: false - default: false + variations: + Default: false + False: false + True: true + targeting: + - name: legacyRuleV0 + query: key eq "not-a-key" + percentage: + False: 0 + True: 100 + defaultRule: + name: legacyDefaultRule + variation: Default From b3272b86a5cf2f06a9a535a6e0decc329ed1acac Mon Sep 17 00:00:00 2001 From: Thomas Poignant Date: Wed, 5 Oct 2022 08:34:32 +0200 Subject: [PATCH 40/50] migration cli binary Signed-off-by: Thomas Poignant --- .gitignore | 3 +++ 1 file changed, 3 insertions(+) diff --git a/.gitignore b/.gitignore index f97b3817bfe..bbf4c638b0b 100644 --- a/.gitignore +++ b/.gitignore @@ -20,3 +20,6 @@ vendor/ # venv created for the documentation script .venv + +# binaries +cmd/migrationcli/migrationcli From 0573fd0743cdb4427a432a2cf1ef1e5d5627cb31 Mon Sep 17 00:00:00 2001 From: Thomas Poignant Date: Wed, 5 Oct 2022 11:32:47 +0200 Subject: [PATCH 41/50] Modify flagv1 for compatibility Signed-off-by: Thomas Poignant --- go.sum | 8 ++------ testutils/flagv1/flag_data.go | 26 +++++++++++++------------- variation_test.go | 2 ++ 3 files changed, 17 insertions(+), 19 deletions(-) diff --git a/go.sum b/go.sum index ab8f7b9f156..aa5972705f1 100644 --- a/go.sum +++ b/go.sum @@ -74,10 +74,8 @@ github.com/PuerkitoBio/urlesc v0.0.0-20170810143723-de5bf2ad4578/go.mod h1:uGdko github.com/alexbrainman/goissue34681 v0.0.0-20191006012335-3fc7a47baff5 h1:iW0a5ljuFxkLGPNem5Ui+KBjFJzKg4Fv2fnxe4dvzpM= github.com/alexbrainman/goissue34681 v0.0.0-20191006012335-3fc7a47baff5/go.mod h1:Y2QMoi1vgtOIfc+6DhrMOGkLoGzqSV2rKp4Sm+opsyA= github.com/antihax/optional v1.0.0/go.mod h1:uupD/76wgC+ih3iEmQUL+0Ugr19nfwCT1kdvxnR2qWY= -github.com/antlr/antlr4/runtime/Go/antlr/v4 v4.0.0-20220911224424-aa1f1f12a846 h1:et5J11AOyUn9qwkIAF9kcxTxjTO8Z9oSmlOqH7MVSPo= -github.com/antlr/antlr4/runtime/Go/antlr/v4 v4.0.0-20220911224424-aa1f1f12a846/go.mod h1:pSwJ0fSY5KhvocuWSx4fz3BA8OrA1bQn+K1Eli3BRwM= -github.com/armon/go-socks5 v0.0.0-20160902184237-e75332964ef5/go.mod h1:wHh0iHkYZB8zMSxRWpUBQtwG5a7fFgvEO+odwuTv2gs= -github.com/asaskevich/govalidator v0.0.0-20190424111038-f61b66f89f4a/go.mod h1:lB+ZfQJz7igIIfQNfa7Ml4HSf2uFQQRzpGGRXenZAgY= +github.com/antlr/antlr4/runtime/Go/antlr v0.0.0-20220415221154-79c36419192d h1:Kts4bTFz6tSE4bPFhcZxpCafiBnSOPSnUaame7SqSDc= +github.com/antlr/antlr4/runtime/Go/antlr v0.0.0-20220415221154-79c36419192d/go.mod h1:F7bn7fEU90QkQ3tnmaTx3LTKLEDqnwWODIYppRQ5hnY= github.com/aws/aws-sdk-go v1.44.109 h1:+Na5JPeS0kiEHoBp5Umcuuf+IDqXqD0lXnM920E31YI= github.com/aws/aws-sdk-go v1.44.109/go.mod h1:y4AeaBuwd2Lk+GepC1E9v0qOiTws0MIWAX4oIKwKHZo= github.com/blang/semver v3.5.1+incompatible h1:cQNTCjp13qL8KC3Nbxr/y2Bqb63oX6wdnnjpJbkM4JQ= @@ -627,8 +625,6 @@ google.golang.org/api v0.75.0/go.mod h1:pU9QmyHLnzlpar1Mjt4IbapUCy8J+6HD6GeELN69 google.golang.org/api v0.78.0/go.mod h1:1Sg78yoMLOhlQTeF+ARBoytAcH1NNyyl390YMy6rKmw= google.golang.org/api v0.80.0/go.mod h1:xY3nI94gbvBrE0J6NHXhxOmW97HG7Khjkku6AFB3Hyg= google.golang.org/api v0.84.0/go.mod h1:NTsGnUFJMYROtiquksZHBWtHfeMC7iYthki7Eq3pa8o= -google.golang.org/api v0.97.0 h1:x/vEL1XDF/2V4xzdNgFPaKHluRESo2aTsL7QzHnBtGQ= -google.golang.org/api v0.97.0/go.mod h1:w7wJQLTM+wvQpNf5JyEcBoxK0RH7EDrh/L4qfsuJ13s= google.golang.org/api v0.98.0 h1:yxZrcxXESimy6r6mdL5Q6EnZwmewDJK2dVg3g75s5Dg= google.golang.org/api v0.98.0/go.mod h1:w7wJQLTM+wvQpNf5JyEcBoxK0RH7EDrh/L4qfsuJ13s= google.golang.org/appengine v1.1.0/go.mod h1:EbEs0AVv82hx2wNQdGPgUI5lhzA/G0D9YwlJXL52JkM= diff --git a/testutils/flagv1/flag_data.go b/testutils/flagv1/flag_data.go index da326b59a3f..067312cdd36 100644 --- a/testutils/flagv1/flag_data.go +++ b/testutils/flagv1/flag_data.go @@ -73,7 +73,7 @@ func (f *FlagData) Value( } // Flag disable we cannot apply it. - if f.GetDisable() { + if f.IsDisable() { return evaluationCtx.DefaultSdkValue, flag.ResolutionDetails{ Variant: flag.VariationSDKDefault, Reason: flag.ReasonDisabled, @@ -160,14 +160,14 @@ func (f FlagData) String() string { toString = append(toString, fmt.Sprintf("true=\"%v\"", f.getTrue())) toString = append(toString, fmt.Sprintf("false=\"%v\"", f.getFalse())) toString = append(toString, fmt.Sprintf("default=\"%v\"", f.getDefault())) - toString = append(toString, fmt.Sprintf("disable=\"%v\"", f.GetDisable())) + toString = append(toString, fmt.Sprintf("disable=\"%v\"", f.IsDisable())) if f.TrackEvents != nil { - toString = append(toString, fmt.Sprintf("trackEvents=\"%v\"", f.GetTrackEvents())) + toString = append(toString, fmt.Sprintf("trackEvents=\"%v\"", f.IsTrackEvents())) } if f.Version != nil { - toString = append(toString, fmt.Sprintf("version=%s", strconv.FormatFloat(f.GetVersion(), 'f', -1, 64))) + toString = append(toString, fmt.Sprintf("version=%s", strconv.FormatFloat(*f.Version, 'f', -1, 64))) } return strings.Join(toString, ", ") @@ -309,16 +309,16 @@ func (f *FlagData) getDefault() interface{} { return *f.Default } -// GetTrackEvents is the getter of the field TrackEvents -func (f *FlagData) GetTrackEvents() bool { +// IsTrackEvents is the getter of the field TrackEvents +func (f *FlagData) IsTrackEvents() bool { if f.TrackEvents == nil { return true } return *f.TrackEvents } -// GetDisable is the getter for the field Disable -func (f *FlagData) GetDisable() bool { +// IsDisable is the getter for the field Disable +func (f *FlagData) IsDisable() bool { if f.Disable == nil { return false } @@ -331,11 +331,11 @@ func (f *FlagData) getRollout() *Rollout { } // GetVersion is the getter for the field Version -func (f *FlagData) GetVersion() float64 { +func (f *FlagData) GetVersion() string { if f.Version == nil { - return 0 + return "" } - return *f.Version + return fmt.Sprintf("%f", *f.Version) } // GetVariationValue return the value of variation from his name @@ -369,8 +369,8 @@ func (f *FlagData) GetRawValues() map[string]string { rawValues["True"] = convertNilEmpty(f.getTrue()) rawValues["False"] = convertNilEmpty(f.getFalse()) rawValues["Default"] = convertNilEmpty(f.getDefault()) - rawValues["TrackEvents"] = fmt.Sprintf("%t", f.GetTrackEvents()) - rawValues["Disable"] = fmt.Sprintf("%t", f.GetDisable()) + rawValues["TrackEvents"] = fmt.Sprintf("%t", f.IsTrackEvents()) + rawValues["Disable"] = fmt.Sprintf("%t", f.IsDisable()) rawValues["Version"] = fmt.Sprintf("%v", f.GetVersion()) return rawValues } diff --git a/variation_test.go b/variation_test.go index ec27552923a..910ec4c6b0c 100644 --- a/variation_test.go +++ b/variation_test.go @@ -9,6 +9,8 @@ import ( "testing" "time" + "github.com/thomaspoignant/go-feature-flag/testutils/flagv1" + "github.com/thomaspoignant/go-feature-flag/internal/model" "github.com/thomaspoignant/go-feature-flag/exporter/fileexporter" From 8180392b25524b1c1b47b6429b3b2bffdeb03a82 Mon Sep 17 00:00:00 2001 From: Thomas Poignant Date: Wed, 12 Oct 2022 09:36:36 +0200 Subject: [PATCH 42/50] fix doc Signed-off-by: Thomas Poignant --- testutils/flagv1/flag_data.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/testutils/flagv1/flag_data.go b/testutils/flagv1/flag_data.go index 067312cdd36..f65650c6e34 100644 --- a/testutils/flagv1/flag_data.go +++ b/testutils/flagv1/flag_data.go @@ -173,7 +173,7 @@ func (f FlagData) String() string { return strings.Join(toString, ", ") } -// getActualPercentage return the the actual percentage of the flag. +// getActualPercentage return the actual percentage of the flag. // the result value is the version with the percentageMultiplier. func (f *FlagData) getActualPercentage() float64 { flagPercentage := f.getPercentage() * percentageMultiplier From 298511e04cf22ca566467312c43b1064f34f5376 Mon Sep 17 00:00:00 2001 From: Thomas Poignant Date: Wed, 12 Oct 2022 09:37:39 +0200 Subject: [PATCH 43/50] Bump go version CI Signed-off-by: Thomas Poignant --- .github/workflows/ci.yml | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index fc13639d637..2227e030fa6 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -15,7 +15,7 @@ jobs: - name: Setup go uses: actions/setup-go@v3 with: - go-version: '^1.16.0' + go-version: '^1.18.0' - run: make lint Test: @@ -26,7 +26,7 @@ jobs: - name: Setup go uses: actions/setup-go@v3 with: - go-version: '^1.16.0' + go-version: '^1.18.0' - run: make test Coverage: @@ -40,7 +40,7 @@ jobs: - name: Setup go uses: actions/setup-go@v3 with: - go-version: '^1.16.0' + go-version: '^1.18.0' - run: make coverage - uses: shogo82148/actions-goveralls@v1 with: @@ -56,7 +56,7 @@ jobs: - name: Setup go uses: actions/setup-go@v3 with: - go-version: '^1.16.0' + go-version: '^1.18.0' - name: Run benchmark run: make bench | tee bench-output.txt - name: Download previous benchmark data From f3d14d7642741135a33c2ae1c4db7345564924b2 Mon Sep 17 00:00:00 2001 From: Thomas Poignant Date: Wed, 12 Oct 2022 09:45:48 +0200 Subject: [PATCH 44/50] Fix antlr dependencies Signed-off-by: Thomas Poignant --- go.sum | 6 ++---- 1 file changed, 2 insertions(+), 4 deletions(-) diff --git a/go.sum b/go.sum index 04ddb1e8c8a..f33adeebe72 100644 --- a/go.sum +++ b/go.sum @@ -74,10 +74,8 @@ github.com/PuerkitoBio/urlesc v0.0.0-20170810143723-de5bf2ad4578/go.mod h1:uGdko github.com/alexbrainman/goissue34681 v0.0.0-20191006012335-3fc7a47baff5 h1:iW0a5ljuFxkLGPNem5Ui+KBjFJzKg4Fv2fnxe4dvzpM= github.com/alexbrainman/goissue34681 v0.0.0-20191006012335-3fc7a47baff5/go.mod h1:Y2QMoi1vgtOIfc+6DhrMOGkLoGzqSV2rKp4Sm+opsyA= github.com/antihax/optional v1.0.0/go.mod h1:uupD/76wgC+ih3iEmQUL+0Ugr19nfwCT1kdvxnR2qWY= -github.com/antlr/antlr4/runtime/Go/antlr/v4 v4.0.0-20220911224424-aa1f1f12a846 h1:et5J11AOyUn9qwkIAF9kcxTxjTO8Z9oSmlOqH7MVSPo= -github.com/antlr/antlr4/runtime/Go/antlr/v4 v4.0.0-20220911224424-aa1f1f12a846/go.mod h1:pSwJ0fSY5KhvocuWSx4fz3BA8OrA1bQn+K1Eli3BRwM= -github.com/armon/go-socks5 v0.0.0-20160902184237-e75332964ef5/go.mod h1:wHh0iHkYZB8zMSxRWpUBQtwG5a7fFgvEO+odwuTv2gs= -github.com/asaskevich/govalidator v0.0.0-20190424111038-f61b66f89f4a/go.mod h1:lB+ZfQJz7igIIfQNfa7Ml4HSf2uFQQRzpGGRXenZAgY= +github.com/antlr/antlr4/runtime/Go/antlr v0.0.0-20220415221154-79c36419192d h1:Kts4bTFz6tSE4bPFhcZxpCafiBnSOPSnUaame7SqSDc= +github.com/antlr/antlr4/runtime/Go/antlr v0.0.0-20220415221154-79c36419192d/go.mod h1:F7bn7fEU90QkQ3tnmaTx3LTKLEDqnwWODIYppRQ5hnY= github.com/aws/aws-sdk-go v1.44.114 h1:plIkWc/RsHr3DXBj4MEw9sEW4CcL/e2ryokc+CKyq1I= github.com/aws/aws-sdk-go v1.44.114/go.mod h1:y4AeaBuwd2Lk+GepC1E9v0qOiTws0MIWAX4oIKwKHZo= github.com/blang/semver v3.5.1+incompatible h1:cQNTCjp13qL8KC3Nbxr/y2Bqb63oX6wdnnjpJbkM4JQ= From 4a507553a81e04506503d4a63cb95c7b1f065c2b Mon Sep 17 00:00:00 2001 From: Thomas Poignant Date: Wed, 12 Oct 2022 11:41:13 +0200 Subject: [PATCH 45/50] Add test for convertion cli Signed-off-by: Thomas Poignant --- cmd/migrationcli/{ => converter}/converter.go | 36 +--- cmd/migrationcli/converter/converter_test.go | 175 ++++++++++++++++++ cmd/migrationcli/main.go | 24 ++- cmd/migrationcli/test.yaml | 13 -- .../testdata/input-experimentation.yaml | 9 + .../testdata/input-progressive-rollout.yaml | 12 ++ .../testdata/input-scheduled.yaml | 13 ++ cmd/migrationcli/testdata/input-simple.json | 10 + cmd/migrationcli/testdata/input-simple.toml | 7 + cmd/migrationcli/testdata/input-simple.yaml | 7 + .../testdata/output-experimentation.yaml | 13 ++ .../testdata/output-progressive-rollout.yaml | 16 ++ .../testdata/output-scheduled.yaml | 39 ++++ cmd/migrationcli/testdata/output-simple.json | 24 +++ cmd/migrationcli/testdata/output-simple.toml | 16 ++ cmd/migrationcli/testdata/output-simple.yaml | 15 ++ 16 files changed, 385 insertions(+), 44 deletions(-) rename cmd/migrationcli/{ => converter}/converter.go (80%) create mode 100644 cmd/migrationcli/converter/converter_test.go delete mode 100644 cmd/migrationcli/test.yaml create mode 100644 cmd/migrationcli/testdata/input-experimentation.yaml create mode 100644 cmd/migrationcli/testdata/input-progressive-rollout.yaml create mode 100644 cmd/migrationcli/testdata/input-scheduled.yaml create mode 100644 cmd/migrationcli/testdata/input-simple.json create mode 100644 cmd/migrationcli/testdata/input-simple.toml create mode 100644 cmd/migrationcli/testdata/input-simple.yaml create mode 100644 cmd/migrationcli/testdata/output-experimentation.yaml create mode 100644 cmd/migrationcli/testdata/output-progressive-rollout.yaml create mode 100755 cmd/migrationcli/testdata/output-scheduled.yaml create mode 100644 cmd/migrationcli/testdata/output-simple.json create mode 100644 cmd/migrationcli/testdata/output-simple.toml create mode 100644 cmd/migrationcli/testdata/output-simple.yaml diff --git a/cmd/migrationcli/converter.go b/cmd/migrationcli/converter/converter.go similarity index 80% rename from cmd/migrationcli/converter.go rename to cmd/migrationcli/converter/converter.go index 6ae522b2f83..d89f45a0492 100644 --- a/cmd/migrationcli/converter.go +++ b/cmd/migrationcli/converter/converter.go @@ -1,4 +1,4 @@ -package main +package converter import ( "bytes" @@ -18,34 +18,24 @@ import ( type FlagConverter struct { InputFile string InputFormat string - OutputFile string OutputFormat string } -func (f *FlagConverter) Migrate() error { +func (f *FlagConverter) Migrate() ([]byte, error) { // Read content of the file content, err := os.ReadFile(f.InputFile) if err != nil { - return fmt.Errorf("file %v is impossible to find", f.InputFile) + return nil, fmt.Errorf("file %v is impossible to find", f.InputFile) } flags, err := f.unmarshall(content) if err != nil { - return err + return nil, err } convertedFlag := f.convert(flags) newFileContent, err := f.marshall(convertedFlag) - if err != nil { - return err - } - - err = f.output(newFileContent) - if err != nil { - return err - } - - return nil + return newFileContent, err } func (f *FlagConverter) unmarshall(content []byte) (map[string]dto.DTO, error) { @@ -56,9 +46,10 @@ func (f *FlagConverter) unmarshall(content []byte) (map[string]dto.DTO, error) { err = toml.Unmarshal(content, &flags) case "json": err = json.Unmarshal(content, &flags) - default: - // default unmarshaller is YAML + case "yaml": err = yaml.Unmarshal(content, &flags) + default: + err = fmt.Errorf("invalid input format %s", f.InputFormat) } if err != nil { return nil, err @@ -83,21 +74,12 @@ func (f *FlagConverter) marshall(convertedFlags map[string]dto.DTO) ([]byte, err _ = toml.NewEncoder(buf).Encode(convertedFlags) return buf.Bytes(), nil case "json": - return json.Marshal(convertedFlags) + return json.MarshalIndent(convertedFlags, "", " ") default: return yaml.Marshal(convertedFlags) } } -func (f *FlagConverter) output(fileContent []byte) error { - if f.OutputFile == "" { - fmt.Println(string(fileContent)) - return nil - } - - return os.WriteFile(f.OutputFile, fileContent, os.ModePerm) -} - func convertToDto(internalFlag flag.InternalFlag) dto.DTO { var experimentation *dto.ExperimentationDto if internalFlag.Experimentation != nil { diff --git a/cmd/migrationcli/converter/converter_test.go b/cmd/migrationcli/converter/converter_test.go new file mode 100644 index 00000000000..747a1ff5724 --- /dev/null +++ b/cmd/migrationcli/converter/converter_test.go @@ -0,0 +1,175 @@ +package converter_test + +import ( + "fmt" + "os" + "testing" + + "github.com/google/go-cmp/cmp" + + "github.com/stretchr/testify/assert" + + "github.com/thomaspoignant/go-feature-flag/cmd/migrationcli/converter" +) + +func TestFlagConverter_Migrate(t *testing.T) { + tests := []struct { + name string + converter converter.FlagConverter + wantFileLocation string + wantErr assert.ErrorAssertionFunc + }{ + { + name: "Simple flag YAML to YAML", + converter: converter.FlagConverter{ + InputFile: "../testdata/input-simple.yaml", + InputFormat: "YAML", + OutputFormat: "YAML", + }, + wantFileLocation: "../testdata/output-simple.yaml", + wantErr: assert.NoError, + }, + { + name: "Simple flag YAML to JSON", + converter: converter.FlagConverter{ + InputFile: "../testdata/input-simple.yaml", + InputFormat: "YAML", + OutputFormat: "JSON", + }, + wantFileLocation: "../testdata/output-simple.json", + wantErr: assert.NoError, + }, + { + name: "Simple flag YAML to TOML", + converter: converter.FlagConverter{ + InputFile: "../testdata/input-simple.yaml", + InputFormat: "YAML", + OutputFormat: "TOML", + }, + wantFileLocation: "../testdata/output-simple.toml", + wantErr: assert.NoError, + }, + { + name: "Simple flag TOML to TOML", + converter: converter.FlagConverter{ + InputFile: "../testdata/input-simple.toml", + InputFormat: "TOML", + OutputFormat: "TOML", + }, + wantFileLocation: "../testdata/output-simple.toml", + wantErr: assert.NoError, + }, + { + name: "Simple flag TOML to JSON", + converter: converter.FlagConverter{ + InputFile: "../testdata/input-simple.toml", + InputFormat: "TOML", + OutputFormat: "JSON", + }, + wantFileLocation: "../testdata/output-simple.json", + wantErr: assert.NoError, + }, + { + name: "Simple flag TOML to YAML", + converter: converter.FlagConverter{ + InputFile: "../testdata/input-simple.toml", + InputFormat: "TOML", + OutputFormat: "YAML", + }, + wantFileLocation: "../testdata/output-simple.yaml", + wantErr: assert.NoError, + }, + { + name: "Simple flag JSON to JSON", + converter: converter.FlagConverter{ + InputFile: "../testdata/input-simple.json", + InputFormat: "JSON", + OutputFormat: "JSON", + }, + wantFileLocation: "../testdata/output-simple.json", + wantErr: assert.NoError, + }, + { + name: "Simple flag JSON to TOML", + converter: converter.FlagConverter{ + InputFile: "../testdata/input-simple.json", + InputFormat: "JSON", + OutputFormat: "TOML", + }, + wantFileLocation: "../testdata/output-simple.toml", + wantErr: assert.NoError, + }, + { + name: "Simple flag JSON to YAML", + converter: converter.FlagConverter{ + InputFile: "../testdata/input-simple.json", + InputFormat: "JSON", + OutputFormat: "YAML", + }, + wantFileLocation: "../testdata/output-simple.yaml", + wantErr: assert.NoError, + }, + { + name: "Progressive rollout flag YAML to YAML", + converter: converter.FlagConverter{ + InputFile: "../testdata/input-progressive-rollout.yaml", + InputFormat: "YAML", + OutputFormat: "YAML", + }, + wantFileLocation: "../testdata/output-progressive-rollout.yaml", + wantErr: assert.NoError, + }, + { + name: "Experimentation rollout flag YAML to YAML", + converter: converter.FlagConverter{ + InputFile: "../testdata/input-experimentation.yaml", + InputFormat: "YAML", + OutputFormat: "YAML", + }, + wantFileLocation: "../testdata/output-experimentation.yaml", + wantErr: assert.NoError, + }, + { + name: "Scheduled rollout flag YAML to YAML", + converter: converter.FlagConverter{ + InputFile: "../testdata/input-scheduled.yaml", + InputFormat: "YAML", + OutputFormat: "YAML", + }, + wantFileLocation: "../testdata/output-scheduled.yaml", + wantErr: assert.NoError, + }, + { + name: "Not valid input format", + converter: converter.FlagConverter{ + InputFile: "../testdata/input-scheduled.yaml", + InputFormat: "YSON", + OutputFormat: "YAML", + }, + wantErr: assert.Error, + }, + { + name: "Invalid input file", + converter: converter.FlagConverter{ + InputFile: "../testdata/input-invalid.yaml", + InputFormat: "YAML", + OutputFormat: "YAML", + }, + wantErr: assert.Error, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + got, err := tt.converter.Migrate() + tt.wantErr(t, err, fmt.Sprintf("Migrate(): %s", err)) + + fmt.Println(string(got)) + + if tt.wantFileLocation != "" { + want, err := os.ReadFile(tt.wantFileLocation) + assert.NoError(t, err) + assert.Equal(t, want, got, cmp.Diff(string(want), string(got))) + } + }) + } +} diff --git a/cmd/migrationcli/main.go b/cmd/migrationcli/main.go index 36fb8c3ccd6..0f85652a64f 100644 --- a/cmd/migrationcli/main.go +++ b/cmd/migrationcli/main.go @@ -1,7 +1,11 @@ package main import ( + "fmt" "log" + "os" + + "github.com/thomaspoignant/go-feature-flag/cmd/migrationcli/converter" "github.com/jessevdk/go-flags" ) @@ -9,7 +13,7 @@ import ( func main() { var opts struct { InputFile string `short:"f" long:"input-file" description:"Location of the flag file you want to convert." required:"true"` //nolint: lll - InputFormat string `long:"input-format" description:"Format of your input file (YAML, JSON or TOML)" required:"false"` //nolint: lll + InputFormat string `long:"input-format" description:"Format of your input file (YAML, JSON or TOML)" required:"true"` //nolint: lll OutputFile string `short:"o" long:"output-file" description:"Location of the flag file you want to convert." required:"false"` //nolint: lll OutputFormat string `long:"output-format" description:"Format of your output file (YAML, JSON or TOML)" required:"false"` //nolint: lll @@ -19,15 +23,27 @@ func main() { log.Fatal("impossible to parse command line parameters", err) } - c := FlagConverter{ + c := converter.FlagConverter{ InputFile: opts.InputFile, InputFormat: opts.InputFormat, - OutputFile: opts.OutputFile, OutputFormat: opts.OutputFormat, } - err = c.Migrate() + content, err := c.Migrate() + if err != nil { + log.Fatal(err) + } + + err = outputResult(content, opts.OutputFile) if err != nil { log.Fatal(err) } } + +func outputResult(content []byte, outputFile string) error { + if outputFile == "" { + fmt.Println(string(content)) + return nil + } + return os.WriteFile(outputFile, content, os.ModePerm) +} diff --git a/cmd/migrationcli/test.yaml b/cmd/migrationcli/test.yaml deleted file mode 100644 index a6b63bc61d6..00000000000 --- a/cmd/migrationcli/test.yaml +++ /dev/null @@ -1,13 +0,0 @@ -test-flag: - rule: key eq "random-key" - percentage: 100 - true: true - false: false - default: false - -test-flag2: - rule: key eq "not-a-key" - percentage: 100 - true: true - false: false - default: false diff --git a/cmd/migrationcli/testdata/input-experimentation.yaml b/cmd/migrationcli/testdata/input-experimentation.yaml new file mode 100644 index 00000000000..30f718939fa --- /dev/null +++ b/cmd/migrationcli/testdata/input-experimentation.yaml @@ -0,0 +1,9 @@ +experimentation-flag: + percentage: 50 + true: "B" + false: "A" + default: "Default" + rollout: + experimentation: + start: 2021-03-20T00:00:00.10-05:00 + end: 2021-03-21T00:00:00.10-05:00 diff --git a/cmd/migrationcli/testdata/input-progressive-rollout.yaml b/cmd/migrationcli/testdata/input-progressive-rollout.yaml new file mode 100644 index 00000000000..2fb9930cc3a --- /dev/null +++ b/cmd/migrationcli/testdata/input-progressive-rollout.yaml @@ -0,0 +1,12 @@ +progressive-flag: + true: "B" + false: "A" + default: "Default" + rollout: + progressive: + percentage: + initial: 0 + end: 100 + releaseRamp: + start: 2021-03-20T00:00:00.10-05:00 + end: 2021-03-21T00:00:00.10-05:00 diff --git a/cmd/migrationcli/testdata/input-scheduled.yaml b/cmd/migrationcli/testdata/input-scheduled.yaml new file mode 100644 index 00000000000..6de8693c30d --- /dev/null +++ b/cmd/migrationcli/testdata/input-scheduled.yaml @@ -0,0 +1,13 @@ +scheduled-flag: + true: "B" + false: "A" + default: "Default" + rollout: + scheduled: + steps: + - date: 2020-04-10T00:00:00.10+02:00 + rule: beta eq "true" + percentage: 100 + + - date: 2022-05-12T15:36:00.10+02:00 + rule: beta eq "false" diff --git a/cmd/migrationcli/testdata/input-simple.json b/cmd/migrationcli/testdata/input-simple.json new file mode 100644 index 00000000000..2bac9dccc38 --- /dev/null +++ b/cmd/migrationcli/testdata/input-simple.json @@ -0,0 +1,10 @@ +{ + "test-flag2": { + "rule": "key eq \"not-a-key\"", + "percentage": 100, + "true": true, + "false": false, + "default": false, + "version": "12" + } +} diff --git a/cmd/migrationcli/testdata/input-simple.toml b/cmd/migrationcli/testdata/input-simple.toml new file mode 100644 index 00000000000..86647e5e9d5 --- /dev/null +++ b/cmd/migrationcli/testdata/input-simple.toml @@ -0,0 +1,7 @@ +[test-flag2] +rule = 'key eq "not-a-key"' +percentage = 100.00 +"true" = true +"false" = false +default = false +version = "12" diff --git a/cmd/migrationcli/testdata/input-simple.yaml b/cmd/migrationcli/testdata/input-simple.yaml new file mode 100644 index 00000000000..0cb23cf41e6 --- /dev/null +++ b/cmd/migrationcli/testdata/input-simple.yaml @@ -0,0 +1,7 @@ +test-flag2: + rule: key eq "not-a-key" + percentage: 100 + true: true + false: false + default: false + version: 12 diff --git a/cmd/migrationcli/testdata/output-experimentation.yaml b/cmd/migrationcli/testdata/output-experimentation.yaml new file mode 100644 index 00000000000..8c36aa0a1b0 --- /dev/null +++ b/cmd/migrationcli/testdata/output-experimentation.yaml @@ -0,0 +1,13 @@ +experimentation-flag: + variations: + Default: Default + "False": A + "True": B + defaultRule: + name: legacyDefaultRule + percentage: + "False": 50 + "True": 50 + experimentation: + start: 2021-03-20T00:00:00.1-05:00 + end: 2021-03-21T00:00:00.1-05:00 diff --git a/cmd/migrationcli/testdata/output-progressive-rollout.yaml b/cmd/migrationcli/testdata/output-progressive-rollout.yaml new file mode 100644 index 00000000000..ee84b62f1a3 --- /dev/null +++ b/cmd/migrationcli/testdata/output-progressive-rollout.yaml @@ -0,0 +1,16 @@ +progressive-flag: + variations: + Default: Default + "False": A + "True": B + defaultRule: + name: legacyDefaultRule + progressiveRollout: + initial: + variation: "False" + percentage: 0 + date: 2021-03-20T00:00:00.1-05:00 + end: + variation: "True" + percentage: 100 + date: 2021-03-21T00:00:00.1-05:00 diff --git a/cmd/migrationcli/testdata/output-scheduled.yaml b/cmd/migrationcli/testdata/output-scheduled.yaml new file mode 100755 index 00000000000..bb5363ce4ce --- /dev/null +++ b/cmd/migrationcli/testdata/output-scheduled.yaml @@ -0,0 +1,39 @@ +scheduled-flag: + variations: + Default: Default + "False": A + "True": B + defaultRule: + name: legacyDefaultRule + percentage: + "False": 100 + "True": 0 + scheduledRollout: + - targeting: + - name: legacyRuleV0 + query: beta eq "true" + percentage: + "False": 0 + "True": 100 + disable: false + defaultRule: + name: legacyDefaultRule + variation: Default + percentage: + "False": -1 + "True": -1 + date: 2020-04-10T00:00:00.1+02:00 + - targeting: + - name: legacyRuleV0 + query: beta eq "false" + percentage: + "False": 100 + "True": 0 + disable: false + defaultRule: + name: legacyDefaultRule + variation: Default + percentage: + "False": -1 + "True": -1 + date: 2022-05-12T15:36:00.1+02:00 diff --git a/cmd/migrationcli/testdata/output-simple.json b/cmd/migrationcli/testdata/output-simple.json new file mode 100644 index 00000000000..f4f0cf251b4 --- /dev/null +++ b/cmd/migrationcli/testdata/output-simple.json @@ -0,0 +1,24 @@ +{ + "test-flag2": { + "variations": { + "Default": false, + "False": false, + "True": true + }, + "targeting": [ + { + "name": "legacyRuleV0", + "query": "key eq \"not-a-key\"", + "percentage": { + "False": 0, + "True": 100 + } + } + ], + "defaultRule": { + "name": "legacyDefaultRule", + "variation": "Default" + }, + "version": "12" + } +} \ No newline at end of file diff --git a/cmd/migrationcli/testdata/output-simple.toml b/cmd/migrationcli/testdata/output-simple.toml new file mode 100644 index 00000000000..b7f92a2a520 --- /dev/null +++ b/cmd/migrationcli/testdata/output-simple.toml @@ -0,0 +1,16 @@ +[test-flag2] + version = "12" + [test-flag2.variations] + Default = false + False = false + True = true + + [[test-flag2.targeting]] + name = "legacyRuleV0" + query = "key eq \"not-a-key\"" + [test-flag2.targeting.percentage] + False = 0.0 + True = 100.0 + [test-flag2.defaultRule] + name = "legacyDefaultRule" + variation = "Default" diff --git a/cmd/migrationcli/testdata/output-simple.yaml b/cmd/migrationcli/testdata/output-simple.yaml new file mode 100644 index 00000000000..3dccf668162 --- /dev/null +++ b/cmd/migrationcli/testdata/output-simple.yaml @@ -0,0 +1,15 @@ +test-flag2: + variations: + Default: false + "False": false + "True": true + targeting: + - name: legacyRuleV0 + query: key eq "not-a-key" + percentage: + "False": 0 + "True": 100 + defaultRule: + name: legacyDefaultRule + variation: Default + version: "12" From ec3a80529990a74dce39afc963f09ce27467ad6f Mon Sep 17 00:00:00 2001 From: Thomas Poignant Date: Wed, 12 Oct 2022 11:54:14 +0200 Subject: [PATCH 46/50] improve makefile Signed-off-by: Thomas Poignant --- Makefile | 57 ++++++++++++++++++++++++++++++++++++++++++++------------ 1 file changed, 45 insertions(+), 12 deletions(-) diff --git a/Makefile b/Makefile index 23636071dc3..ab9d5d91998 100644 --- a/Makefile +++ b/Makefile @@ -2,23 +2,56 @@ GOCMD=go GOTEST=$(GOCMD) test GOVET=$(GOCMD) vet +GREEN := $(shell tput -Txterm setaf 2) +YELLOW := $(shell tput -Txterm setaf 3) +WHITE := $(shell tput -Txterm setaf 7) +CYAN := $(shell tput -Txterm setaf 6) +RESET := $(shell tput -Txterm sgr0) + .PHONY: all test build vendor -lint: - mkdir -p ./bin - # Install linters - curl -sSfL https://raw.githubusercontent.com/golangci/golangci-lint/master/install.sh | sh -s latest - # Run linters - ./bin/golangci-lint run --deadline=3m --timeout=3m ./... +all: help -test: - $(GOTEST) -v -race ./... +## Build: +build: build-migrationcli ## Build all the binaries and put the output in out/bin/ -coverage: - $(GOTEST) -cover -covermode=count -coverprofile=coverage.cov ./... +build-migrationcli: ## Build the migration cli out/bin/ + mkdir -p out/bin + GO111MODULE=on $(GOCMD) build -mod vendor -o out/bin/migrationcli ./cmd/migrationcli/ + +clean: ## Remove build related file + rm -fr ./bin + rm -fr ./out + rm -f ./junit-report.xml checkstyle-report.xml ./coverage.xml ./profile.cov yamllint-checkstyle.xml -vendor: +vendor: ## Copy of all packages needed to support builds and tests in the vendor directory + $(GOCMD) mod tidy $(GOCMD) mod vendor -bench: +## Test: +test: ## Run the tests of the project + $(GOTEST) -v -race ./... + +coverage: ## Run the tests of the project and export the coverage + $(GOTEST) -cover -covermode=count -coverprofile=coverage.cov ./... + +bench: ## Launch the benchmark test $(GOTEST) -bench Benchmark -cpu 2 -run=^$$ + +## Lint: +lint: ## Use golintci-lint on your project + mkdir -p ./bin + curl -sSfL https://raw.githubusercontent.com/golangci/golangci-lint/master/install.sh | sh -s latest # Install linters + ./bin/golangci-lint run --deadline=3m --timeout=3m ./... # Run linters + +## Help: +help: ## Show this help. + @echo '' + @echo 'Usage:' + @echo ' ${YELLOW}make${RESET} ${GREEN}${RESET}' + @echo '' + @echo 'Targets:' + @awk 'BEGIN {FS = ":.*?## "} { \ + if (/^[a-zA-Z_-]+:.*?##.*$$/) {printf " ${YELLOW}%-20s${GREEN}%s${RESET}\n", $$1, $$2} \ + else if (/^## .*$$/) {printf " ${CYAN}%s${RESET}\n", substr($$1,4)} \ + }' $(MAKEFILE_LIST) From dc229d42e401ad9c057e560bd43bf17b7f31a6ca Mon Sep 17 00:00:00 2001 From: Thomas Poignant Date: Wed, 12 Oct 2022 11:56:55 +0200 Subject: [PATCH 47/50] remove unused function Signed-off-by: Thomas Poignant --- testutils/flagv1/rollout.go | 8 -------- 1 file changed, 8 deletions(-) diff --git a/testutils/flagv1/rollout.go b/testutils/flagv1/rollout.go index 13d14294818..0219a4dac79 100644 --- a/testutils/flagv1/rollout.go +++ b/testutils/flagv1/rollout.go @@ -24,14 +24,6 @@ type Rollout struct { Scheduled *ScheduledRollout `json:"scheduled,omitempty" yaml:"scheduled,omitempty" toml:"scheduled,omitempty"` // nolint: lll } -func (e Rollout) String() string { - // TODO: other rollout - if e.Experimentation == nil { - return "" - } - return "experimentation: " + e.Experimentation.String() -} - type Experimentation struct { // Start is the starting time of the experimentation Start *time.Time `json:"start,omitempty" yaml:"start,omitempty" toml:"start,omitempty"` From e4d8f4fa96fec279b4713f30c1821096c3c43d75 Mon Sep 17 00:00:00 2001 From: Thomas Poignant Date: Wed, 12 Oct 2022 11:59:42 +0200 Subject: [PATCH 48/50] remove Print Signed-off-by: Thomas Poignant --- cmd/migrationcli/converter/converter_test.go | 3 --- exporter/webhookexporter/exporter_test.go | 3 +-- notifier/slacknotifier/notifier.go | 6 +----- 3 files changed, 2 insertions(+), 10 deletions(-) diff --git a/cmd/migrationcli/converter/converter_test.go b/cmd/migrationcli/converter/converter_test.go index 747a1ff5724..935c319239a 100644 --- a/cmd/migrationcli/converter/converter_test.go +++ b/cmd/migrationcli/converter/converter_test.go @@ -162,9 +162,6 @@ func TestFlagConverter_Migrate(t *testing.T) { t.Run(tt.name, func(t *testing.T) { got, err := tt.converter.Migrate() tt.wantErr(t, err, fmt.Sprintf("Migrate(): %s", err)) - - fmt.Println(string(got)) - if tt.wantFileLocation != "" { want, err := os.ReadFile(tt.wantFileLocation) assert.NoError(t, err) diff --git a/exporter/webhookexporter/exporter_test.go b/exporter/webhookexporter/exporter_test.go index 0c1e6863b0a..59a230e16e1 100644 --- a/exporter/webhookexporter/exporter_test.go +++ b/exporter/webhookexporter/exporter_test.go @@ -2,7 +2,6 @@ package webhookexporter import ( "context" - "fmt" "log" "os" "testing" @@ -166,7 +165,7 @@ func TestWebhook_Export(t *testing.T) { assert.NoError(t, err) if tt.expected.bodyFilePath != "" { c, err := os.ReadFile(tt.expected.bodyFilePath) - fmt.Println(err) + assert.NoError(t, err) assert.JSONEq(t, string(c), tt.fields.httpClient.Body) } diff --git a/notifier/slacknotifier/notifier.go b/notifier/slacknotifier/notifier.go index 4c83fb4d628..d73594233e4 100644 --- a/notifier/slacknotifier/notifier.go +++ b/notifier/slacknotifier/notifier.go @@ -118,11 +118,7 @@ func convertUpdatedFlagsToSlackMessage(diffCache notifier.DiffCache) []attachmen Fields: []Field{}, } - changelog, err := diff.Diff(value.Before, value.After, diff.AllowTypeMismatch(true)) - if err != nil { - fmt.Println(err) - } - + changelog, _ := diff.Diff(value.Before, value.After, diff.AllowTypeMismatch(true)) for _, change := range changelog { if change.Type == "update" { value := fmt.Sprintf("%s => %s", render.Render(change.From), render.Render(change.To)) From 82951a228c5b899c2fccd793eb405b1bfcde1177 Mon Sep 17 00:00:00 2001 From: Thomas Poignant Date: Wed, 12 Oct 2022 13:39:02 +0200 Subject: [PATCH 49/50] remove header for v1 Signed-off-by: Thomas Poignant --- README.md | 4 ---- 1 file changed, 4 deletions(-) diff --git a/README.md b/README.md index f1c36a19162..a40b38f1ec5 100644 --- a/README.md +++ b/README.md @@ -1,7 +1,3 @@ -> ## go-feature-flag v1 feedback -> go-feature-flag is heading towards v1 and it may require a change on how to design your flags _(no worries we will keep backward compatibility)_. -> The roadmap is now publicly available in this [issue #291](https://github.com/thomaspoignant/go-feature-flag/issues/291), feel free to comment and give any feedback. -

go-feature-flag logo

From 51f7ad7e4cb30805ce2f481d95fd17c54854ca67 Mon Sep 17 00:00:00 2001 From: Thomas Poignant Date: Wed, 12 Oct 2022 15:10:49 +0200 Subject: [PATCH 50/50] Format the files Signed-off-by: Thomas Poignant --- examples/data_export_file/flags.yaml | 1 - testdata/flag-config-big.yaml | 130018 +++++++++++++++------- testdata/flag-config-scheduled-v0.yaml | 74 +- testdata/flag-config-updated.yaml | 36 +- testdata/test-instance2.yaml | 36 +- 5 files changed, 90111 insertions(+), 40054 deletions(-) mode change 100644 => 100755 testdata/flag-config-big.yaml mode change 100644 => 100755 testdata/flag-config-scheduled-v0.yaml mode change 100644 => 100755 testdata/test-instance2.yaml diff --git a/examples/data_export_file/flags.yaml b/examples/data_export_file/flags.yaml index 1061f4ebdb6..1c38b296bf5 100644 --- a/examples/data_export_file/flags.yaml +++ b/examples/data_export_file/flags.yaml @@ -4,7 +4,6 @@ new-admin-access: false: false default: false - flag-only-for-admin: rule: admin eq true percentage: 100 diff --git a/testdata/flag-config-big.yaml b/testdata/flag-config-big.yaml old mode 100644 new mode 100755 index 6c601f83457..31fba4e94ce --- a/testdata/flag-config-big.yaml +++ b/testdata/flag-config-big.yaml @@ -1,50009 +1,100009 @@ test-flag0: - percentage: 0 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 100 + "True": 0 test-flag1: - percentage: 1 - true: "true" - false: "false" - default: "false" + variations: + Default: "false" + "False": "false" + "True": "true" + defaultRule: + name: legacyDefaultRule + percentage: + "False": 99 + "True": 1 test-flag2: - percentage: 2 - true: 1 - false: 2 - default: 3 + variations: + Default: 3 + "False": 2 + "True": 1 + defaultRule: + name: legacyDefaultRule + percentage: + "False": 98 + "True": 2 test-flag3: - percentage: 3 - true: - - yo - - ya - false: - - yo - - ya - default: - - yo - - ya + variations: + Default: + - yo + - ya + "False": + - yo + - ya + "True": + - yo + - ya + defaultRule: + name: legacyDefaultRule + percentage: + "False": 97 + "True": 3 test-flag4: - percentage: 4 - true: - test: yo - false: - test: yo - default: - test: yo + variations: + Default: + test: yo + "False": + test: yo + "True": + test: yo + defaultRule: + name: legacyDefaultRule + percentage: + "False": 96 + "True": 4 test-flag5: - percentage: 5 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 95 + "True": 5 test-flag6: - percentage: 6 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 94 + "True": 6 test-flag7: - percentage: 7 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 93 + "True": 7 test-flag8: - percentage: 8 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 92 + "True": 8 test-flag9: - percentage: 9 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 91 + "True": 9 test-flag10: - percentage: 10 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 90 + "True": 10 test-flag11: - percentage: 11 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 89 + "True": 11 test-flag12: - percentage: 12 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 88 + "True": 12 test-flag13: - percentage: 13 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 87 + "True": 13 test-flag14: - percentage: 14 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 86 + "True": 14 test-flag15: - percentage: 15 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 85 + "True": 15 test-flag16: - percentage: 16 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 84 + "True": 16 test-flag17: - percentage: 17 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 83 + "True": 17 test-flag18: - percentage: 18 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 82 + "True": 18 test-flag19: - percentage: 19 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 81 + "True": 19 test-flag20: - percentage: 20 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 80 + "True": 20 test-flag21: - percentage: 21 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 79 + "True": 21 test-flag22: - percentage: 22 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 78 + "True": 22 test-flag23: - percentage: 23 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 77 + "True": 23 test-flag24: - percentage: 24 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 76 + "True": 24 test-flag25: - percentage: 25 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 75 + "True": 25 test-flag26: - percentage: 26 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 74 + "True": 26 test-flag27: - percentage: 27 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 73 + "True": 27 test-flag28: - percentage: 28 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 72 + "True": 28 test-flag29: - percentage: 29 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 71 + "True": 29 test-flag30: - percentage: 30 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 70 + "True": 30 test-flag31: - percentage: 31 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 69 + "True": 31 test-flag32: - percentage: 32 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 68 + "True": 32 test-flag33: - percentage: 33 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 67 + "True": 33 test-flag34: - percentage: 34 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 66 + "True": 34 test-flag35: - percentage: 35 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 65 + "True": 35 test-flag36: - percentage: 36 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 64 + "True": 36 test-flag37: - percentage: 37 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 63 + "True": 37 test-flag38: - percentage: 38 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 62 + "True": 38 test-flag39: - percentage: 39 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 61 + "True": 39 test-flag40: - percentage: 40 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 60 + "True": 40 test-flag41: - percentage: 41 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 59 + "True": 41 test-flag42: - percentage: 42 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 58 + "True": 42 test-flag43: - percentage: 43 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 57 + "True": 43 test-flag44: - percentage: 44 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 56 + "True": 44 test-flag45: - percentage: 45 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 55 + "True": 45 test-flag46: - percentage: 46 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 54 + "True": 46 test-flag47: - percentage: 47 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 53 + "True": 47 test-flag48: - percentage: 48 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 52 + "True": 48 test-flag49: - percentage: 49 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 51 + "True": 49 test-flag50: - percentage: 50 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 50 + "True": 50 test-flag51: - percentage: 51 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 49 + "True": 51 test-flag52: - percentage: 52 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 48 + "True": 52 test-flag53: - percentage: 53 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 47 + "True": 53 test-flag54: - percentage: 54 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 46 + "True": 54 test-flag55: - percentage: 55 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 45 + "True": 55 test-flag56: - percentage: 56 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 44 + "True": 56 test-flag57: - percentage: 57 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 43 + "True": 57 test-flag58: - percentage: 58 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 42 + "True": 58 test-flag59: - percentage: 59 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 41 + "True": 59 test-flag60: - percentage: 60 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 40 + "True": 60 test-flag61: - percentage: 61 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 39 + "True": 61 test-flag62: - percentage: 62 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 38 + "True": 62 test-flag63: - percentage: 63 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 37 + "True": 63 test-flag64: - percentage: 64 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 36 + "True": 64 test-flag65: - percentage: 65 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 35 + "True": 65 test-flag66: - percentage: 66 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 34 + "True": 66 test-flag67: - percentage: 67 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 33 + "True": 67 test-flag68: - percentage: 68 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 32 + "True": 68 test-flag69: - percentage: 69 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 31 + "True": 69 test-flag70: - percentage: 70 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 30 + "True": 70 test-flag71: - percentage: 71 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 29 + "True": 71 test-flag72: - percentage: 72 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 28 + "True": 72 test-flag73: - percentage: 73 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 27 + "True": 73 test-flag74: - percentage: 74 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 26 + "True": 74 test-flag75: - percentage: 75 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 25 + "True": 75 test-flag76: - percentage: 76 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 24 + "True": 76 test-flag77: - percentage: 77 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 23 + "True": 77 test-flag78: - percentage: 78 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 22 + "True": 78 test-flag79: - percentage: 79 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 21 + "True": 79 test-flag80: - percentage: 80 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 20 + "True": 80 test-flag81: - percentage: 81 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 19 + "True": 81 test-flag82: - percentage: 82 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 18 + "True": 82 test-flag83: - percentage: 83 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 17 + "True": 83 test-flag84: - percentage: 84 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 16 + "True": 84 test-flag85: - percentage: 85 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 15 + "True": 85 test-flag86: - percentage: 86 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 14 + "True": 86 test-flag87: - percentage: 87 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 13 + "True": 87 test-flag88: - percentage: 88 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 12 + "True": 88 test-flag89: - percentage: 89 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 11 + "True": 89 test-flag90: - percentage: 90 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 10 + "True": 90 test-flag91: - percentage: 91 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 9 + "True": 91 test-flag92: - percentage: 92 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 8 + "True": 92 test-flag93: - percentage: 93 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 7 + "True": 93 test-flag94: - percentage: 94 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 6 + "True": 94 test-flag95: - percentage: 95 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 5 + "True": 95 test-flag96: - percentage: 96 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 4 + "True": 96 test-flag97: - percentage: 97 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 3 + "True": 97 test-flag98: - percentage: 98 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 2 + "True": 98 test-flag99: - percentage: 99 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 1 + "True": 99 test-flag100: - percentage: 0 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 100 + "True": 0 test-flag101: - percentage: 1 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 99 + "True": 1 test-flag102: - percentage: 2 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 98 + "True": 2 test-flag103: - percentage: 3 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 97 + "True": 3 test-flag104: - percentage: 4 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 96 + "True": 4 test-flag105: - percentage: 5 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 95 + "True": 5 test-flag106: - percentage: 6 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 94 + "True": 6 test-flag107: - percentage: 7 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 93 + "True": 7 test-flag108: - percentage: 8 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 92 + "True": 8 test-flag109: - percentage: 9 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 91 + "True": 9 test-flag110: - percentage: 10 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 90 + "True": 10 test-flag111: - percentage: 11 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 89 + "True": 11 test-flag112: - percentage: 12 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 88 + "True": 12 test-flag113: - percentage: 13 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 87 + "True": 13 test-flag114: - percentage: 14 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 86 + "True": 14 test-flag115: - percentage: 15 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 85 + "True": 15 test-flag116: - percentage: 16 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 84 + "True": 16 test-flag117: - percentage: 17 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 83 + "True": 17 test-flag118: - percentage: 18 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 82 + "True": 18 test-flag119: - percentage: 19 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 81 + "True": 19 test-flag120: - percentage: 20 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 80 + "True": 20 test-flag121: - percentage: 21 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 79 + "True": 21 test-flag122: - percentage: 22 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 78 + "True": 22 test-flag123: - percentage: 23 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 77 + "True": 23 test-flag124: - percentage: 24 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 76 + "True": 24 test-flag125: - percentage: 25 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 75 + "True": 25 test-flag126: - percentage: 26 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 74 + "True": 26 test-flag127: - percentage: 27 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 73 + "True": 27 test-flag128: - percentage: 28 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 72 + "True": 28 test-flag129: - percentage: 29 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 71 + "True": 29 test-flag130: - percentage: 30 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 70 + "True": 30 test-flag131: - percentage: 31 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 69 + "True": 31 test-flag132: - percentage: 32 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 68 + "True": 32 test-flag133: - percentage: 33 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 67 + "True": 33 test-flag134: - percentage: 34 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 66 + "True": 34 test-flag135: - percentage: 35 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 65 + "True": 35 test-flag136: - percentage: 36 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 64 + "True": 36 test-flag137: - percentage: 37 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 63 + "True": 37 test-flag138: - percentage: 38 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 62 + "True": 38 test-flag139: - percentage: 39 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 61 + "True": 39 test-flag140: - percentage: 40 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 60 + "True": 40 test-flag141: - percentage: 41 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 59 + "True": 41 test-flag142: - percentage: 42 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 58 + "True": 42 test-flag143: - percentage: 43 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 57 + "True": 43 test-flag144: - percentage: 44 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 56 + "True": 44 test-flag145: - percentage: 45 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 55 + "True": 45 test-flag146: - percentage: 46 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 54 + "True": 46 test-flag147: - percentage: 47 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 53 + "True": 47 test-flag148: - percentage: 48 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 52 + "True": 48 test-flag149: - percentage: 49 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 51 + "True": 49 test-flag150: - percentage: 50 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 50 + "True": 50 test-flag151: - percentage: 51 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 49 + "True": 51 test-flag152: - percentage: 52 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 48 + "True": 52 test-flag153: - percentage: 53 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 47 + "True": 53 test-flag154: - percentage: 54 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 46 + "True": 54 test-flag155: - percentage: 55 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 45 + "True": 55 test-flag156: - percentage: 56 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 44 + "True": 56 test-flag157: - percentage: 57 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 43 + "True": 57 test-flag158: - percentage: 58 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 42 + "True": 58 test-flag159: - percentage: 59 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 41 + "True": 59 test-flag160: - percentage: 60 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 40 + "True": 60 test-flag161: - percentage: 61 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 39 + "True": 61 test-flag162: - percentage: 62 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 38 + "True": 62 test-flag163: - percentage: 63 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 37 + "True": 63 test-flag164: - percentage: 64 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 36 + "True": 64 test-flag165: - percentage: 65 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 35 + "True": 65 test-flag166: - percentage: 66 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 34 + "True": 66 test-flag167: - percentage: 67 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 33 + "True": 67 test-flag168: - percentage: 68 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 32 + "True": 68 test-flag169: - percentage: 69 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 31 + "True": 69 test-flag170: - percentage: 70 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 30 + "True": 70 test-flag171: - percentage: 71 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 29 + "True": 71 test-flag172: - percentage: 72 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 28 + "True": 72 test-flag173: - percentage: 73 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 27 + "True": 73 test-flag174: - percentage: 74 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 26 + "True": 74 test-flag175: - percentage: 75 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 25 + "True": 75 test-flag176: - percentage: 76 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 24 + "True": 76 test-flag177: - percentage: 77 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 23 + "True": 77 test-flag178: - percentage: 78 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 22 + "True": 78 test-flag179: - percentage: 79 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 21 + "True": 79 test-flag180: - percentage: 80 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 20 + "True": 80 test-flag181: - percentage: 81 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 19 + "True": 81 test-flag182: - percentage: 82 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 18 + "True": 82 test-flag183: - percentage: 83 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 17 + "True": 83 test-flag184: - percentage: 84 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 16 + "True": 84 test-flag185: - percentage: 85 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 15 + "True": 85 test-flag186: - percentage: 86 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 14 + "True": 86 test-flag187: - percentage: 87 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 13 + "True": 87 test-flag188: - percentage: 88 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 12 + "True": 88 test-flag189: - percentage: 89 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 11 + "True": 89 test-flag190: - percentage: 90 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 10 + "True": 90 test-flag191: - percentage: 91 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 9 + "True": 91 test-flag192: - percentage: 92 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 8 + "True": 92 test-flag193: - percentage: 93 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 7 + "True": 93 test-flag194: - percentage: 94 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 6 + "True": 94 test-flag195: - percentage: 95 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 5 + "True": 95 test-flag196: - percentage: 96 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 4 + "True": 96 test-flag197: - percentage: 97 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 3 + "True": 97 test-flag198: - percentage: 98 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 2 + "True": 98 test-flag199: - percentage: 99 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 1 + "True": 99 test-flag200: - percentage: 0 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 100 + "True": 0 test-flag201: - percentage: 1 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 99 + "True": 1 test-flag202: - percentage: 2 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 98 + "True": 2 test-flag203: - percentage: 3 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 97 + "True": 3 test-flag204: - percentage: 4 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 96 + "True": 4 test-flag205: - percentage: 5 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 95 + "True": 5 test-flag206: - percentage: 6 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 94 + "True": 6 test-flag207: - percentage: 7 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 93 + "True": 7 test-flag208: - percentage: 8 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 92 + "True": 8 test-flag209: - percentage: 9 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 91 + "True": 9 test-flag210: - percentage: 10 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 90 + "True": 10 test-flag211: - percentage: 11 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 89 + "True": 11 test-flag212: - percentage: 12 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 88 + "True": 12 test-flag213: - percentage: 13 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 87 + "True": 13 test-flag214: - percentage: 14 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 86 + "True": 14 test-flag215: - percentage: 15 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 85 + "True": 15 test-flag216: - percentage: 16 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 84 + "True": 16 test-flag217: - percentage: 17 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 83 + "True": 17 test-flag218: - percentage: 18 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 82 + "True": 18 test-flag219: - percentage: 19 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 81 + "True": 19 test-flag220: - percentage: 20 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 80 + "True": 20 test-flag221: - percentage: 21 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 79 + "True": 21 test-flag222: - percentage: 22 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 78 + "True": 22 test-flag223: - percentage: 23 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 77 + "True": 23 test-flag224: - percentage: 24 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 76 + "True": 24 test-flag225: - percentage: 25 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 75 + "True": 25 test-flag226: - percentage: 26 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 74 + "True": 26 test-flag227: - percentage: 27 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 73 + "True": 27 test-flag228: - percentage: 28 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 72 + "True": 28 test-flag229: - percentage: 29 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 71 + "True": 29 test-flag230: - percentage: 30 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 70 + "True": 30 test-flag231: - percentage: 31 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 69 + "True": 31 test-flag232: - percentage: 32 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 68 + "True": 32 test-flag233: - percentage: 33 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 67 + "True": 33 test-flag234: - percentage: 34 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 66 + "True": 34 test-flag235: - percentage: 35 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 65 + "True": 35 test-flag236: - percentage: 36 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 64 + "True": 36 test-flag237: - percentage: 37 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 63 + "True": 37 test-flag238: - percentage: 38 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 62 + "True": 38 test-flag239: - percentage: 39 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 61 + "True": 39 test-flag240: - percentage: 40 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 60 + "True": 40 test-flag241: - percentage: 41 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 59 + "True": 41 test-flag242: - percentage: 42 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 58 + "True": 42 test-flag243: - percentage: 43 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 57 + "True": 43 test-flag244: - percentage: 44 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 56 + "True": 44 test-flag245: - percentage: 45 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 55 + "True": 45 test-flag246: - percentage: 46 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 54 + "True": 46 test-flag247: - percentage: 47 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 53 + "True": 47 test-flag248: - percentage: 48 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 52 + "True": 48 test-flag249: - percentage: 49 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 51 + "True": 49 test-flag250: - percentage: 50 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 50 + "True": 50 test-flag251: - percentage: 51 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 49 + "True": 51 test-flag252: - percentage: 52 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 48 + "True": 52 test-flag253: - percentage: 53 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 47 + "True": 53 test-flag254: - percentage: 54 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 46 + "True": 54 test-flag255: - percentage: 55 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 45 + "True": 55 test-flag256: - percentage: 56 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 44 + "True": 56 test-flag257: - percentage: 57 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 43 + "True": 57 test-flag258: - percentage: 58 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 42 + "True": 58 test-flag259: - percentage: 59 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 41 + "True": 59 test-flag260: - percentage: 60 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 40 + "True": 60 test-flag261: - percentage: 61 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 39 + "True": 61 test-flag262: - percentage: 62 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 38 + "True": 62 test-flag263: - percentage: 63 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 37 + "True": 63 test-flag264: - percentage: 64 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 36 + "True": 64 test-flag265: - percentage: 65 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 35 + "True": 65 test-flag266: - percentage: 66 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 34 + "True": 66 test-flag267: - percentage: 67 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 33 + "True": 67 test-flag268: - percentage: 68 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 32 + "True": 68 test-flag269: - percentage: 69 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 31 + "True": 69 test-flag270: - percentage: 70 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 30 + "True": 70 test-flag271: - percentage: 71 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 29 + "True": 71 test-flag272: - percentage: 72 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 28 + "True": 72 test-flag273: - percentage: 73 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 27 + "True": 73 test-flag274: - percentage: 74 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 26 + "True": 74 test-flag275: - percentage: 75 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 25 + "True": 75 test-flag276: - percentage: 76 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 24 + "True": 76 test-flag277: - percentage: 77 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 23 + "True": 77 test-flag278: - percentage: 78 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 22 + "True": 78 test-flag279: - percentage: 79 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 21 + "True": 79 test-flag280: - percentage: 80 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 20 + "True": 80 test-flag281: - percentage: 81 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 19 + "True": 81 test-flag282: - percentage: 82 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 18 + "True": 82 test-flag283: - percentage: 83 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 17 + "True": 83 test-flag284: - percentage: 84 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 16 + "True": 84 test-flag285: - percentage: 85 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 15 + "True": 85 test-flag286: - percentage: 86 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 14 + "True": 86 test-flag287: - percentage: 87 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 13 + "True": 87 test-flag288: - percentage: 88 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 12 + "True": 88 test-flag289: - percentage: 89 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 11 + "True": 89 test-flag290: - percentage: 90 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 10 + "True": 90 test-flag291: - percentage: 91 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 9 + "True": 91 test-flag292: - percentage: 92 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 8 + "True": 92 test-flag293: - percentage: 93 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 7 + "True": 93 test-flag294: - percentage: 94 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 6 + "True": 94 test-flag295: - percentage: 95 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 5 + "True": 95 test-flag296: - percentage: 96 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 4 + "True": 96 test-flag297: - percentage: 97 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 3 + "True": 97 test-flag298: - percentage: 98 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 2 + "True": 98 test-flag299: - percentage: 99 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 1 + "True": 99 test-flag300: - percentage: 0 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 100 + "True": 0 test-flag301: - percentage: 1 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 99 + "True": 1 test-flag302: - percentage: 2 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 98 + "True": 2 test-flag303: - percentage: 3 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 97 + "True": 3 test-flag304: - percentage: 4 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 96 + "True": 4 test-flag305: - percentage: 5 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 95 + "True": 5 test-flag306: - percentage: 6 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 94 + "True": 6 test-flag307: - percentage: 7 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 93 + "True": 7 test-flag308: - percentage: 8 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 92 + "True": 8 test-flag309: - percentage: 9 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 91 + "True": 9 test-flag310: - percentage: 10 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 90 + "True": 10 test-flag311: - percentage: 11 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 89 + "True": 11 test-flag312: - percentage: 12 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 88 + "True": 12 test-flag313: - percentage: 13 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 87 + "True": 13 test-flag314: - percentage: 14 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 86 + "True": 14 test-flag315: - percentage: 15 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 85 + "True": 15 test-flag316: - percentage: 16 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 84 + "True": 16 test-flag317: - percentage: 17 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 83 + "True": 17 test-flag318: - percentage: 18 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 82 + "True": 18 test-flag319: - percentage: 19 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 81 + "True": 19 test-flag320: - percentage: 20 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 80 + "True": 20 test-flag321: - percentage: 21 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 79 + "True": 21 test-flag322: - percentage: 22 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 78 + "True": 22 test-flag323: - percentage: 23 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 77 + "True": 23 test-flag324: - percentage: 24 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 76 + "True": 24 test-flag325: - percentage: 25 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 75 + "True": 25 test-flag326: - percentage: 26 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 74 + "True": 26 test-flag327: - percentage: 27 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 73 + "True": 27 test-flag328: - percentage: 28 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 72 + "True": 28 test-flag329: - percentage: 29 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 71 + "True": 29 test-flag330: - percentage: 30 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 70 + "True": 30 test-flag331: - percentage: 31 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 69 + "True": 31 test-flag332: - percentage: 32 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 68 + "True": 32 test-flag333: - percentage: 33 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 67 + "True": 33 test-flag334: - percentage: 34 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 66 + "True": 34 test-flag335: - percentage: 35 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 65 + "True": 35 test-flag336: - percentage: 36 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 64 + "True": 36 test-flag337: - percentage: 37 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 63 + "True": 37 test-flag338: - percentage: 38 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 62 + "True": 38 test-flag339: - percentage: 39 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 61 + "True": 39 test-flag340: - percentage: 40 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 60 + "True": 40 test-flag341: - percentage: 41 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 59 + "True": 41 test-flag342: - percentage: 42 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 58 + "True": 42 test-flag343: - percentage: 43 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 57 + "True": 43 test-flag344: - percentage: 44 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 56 + "True": 44 test-flag345: - percentage: 45 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 55 + "True": 45 test-flag346: - percentage: 46 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 54 + "True": 46 test-flag347: - percentage: 47 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 53 + "True": 47 test-flag348: - percentage: 48 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 52 + "True": 48 test-flag349: - percentage: 49 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 51 + "True": 49 test-flag350: - percentage: 50 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 50 + "True": 50 test-flag351: - percentage: 51 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 49 + "True": 51 test-flag352: - percentage: 52 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 48 + "True": 52 test-flag353: - percentage: 53 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 47 + "True": 53 test-flag354: - percentage: 54 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 46 + "True": 54 test-flag355: - percentage: 55 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 45 + "True": 55 test-flag356: - percentage: 56 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 44 + "True": 56 test-flag357: - percentage: 57 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 43 + "True": 57 test-flag358: - percentage: 58 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 42 + "True": 58 test-flag359: - percentage: 59 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 41 + "True": 59 test-flag360: - percentage: 60 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 40 + "True": 60 test-flag361: - percentage: 61 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 39 + "True": 61 test-flag362: - percentage: 62 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 38 + "True": 62 test-flag363: - percentage: 63 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 37 + "True": 63 test-flag364: - percentage: 64 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 36 + "True": 64 test-flag365: - percentage: 65 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 35 + "True": 65 test-flag366: - percentage: 66 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 34 + "True": 66 test-flag367: - percentage: 67 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 33 + "True": 67 test-flag368: - percentage: 68 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 32 + "True": 68 test-flag369: - percentage: 69 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 31 + "True": 69 test-flag370: - percentage: 70 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 30 + "True": 70 test-flag371: - percentage: 71 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 29 + "True": 71 test-flag372: - percentage: 72 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 28 + "True": 72 test-flag373: - percentage: 73 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 27 + "True": 73 test-flag374: - percentage: 74 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 26 + "True": 74 test-flag375: - percentage: 75 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 25 + "True": 75 test-flag376: - percentage: 76 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 24 + "True": 76 test-flag377: - percentage: 77 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 23 + "True": 77 test-flag378: - percentage: 78 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 22 + "True": 78 test-flag379: - percentage: 79 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 21 + "True": 79 test-flag380: - percentage: 80 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 20 + "True": 80 test-flag381: - percentage: 81 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 19 + "True": 81 test-flag382: - percentage: 82 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 18 + "True": 82 test-flag383: - percentage: 83 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 17 + "True": 83 test-flag384: - percentage: 84 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 16 + "True": 84 test-flag385: - percentage: 85 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 15 + "True": 85 test-flag386: - percentage: 86 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 14 + "True": 86 test-flag387: - percentage: 87 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 13 + "True": 87 test-flag388: - percentage: 88 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 12 + "True": 88 test-flag389: - percentage: 89 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 11 + "True": 89 test-flag390: - percentage: 90 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 10 + "True": 90 test-flag391: - percentage: 91 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 9 + "True": 91 test-flag392: - percentage: 92 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 8 + "True": 92 test-flag393: - percentage: 93 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 7 + "True": 93 test-flag394: - percentage: 94 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 6 + "True": 94 test-flag395: - percentage: 95 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 5 + "True": 95 test-flag396: - percentage: 96 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 4 + "True": 96 test-flag397: - percentage: 97 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 3 + "True": 97 test-flag398: - percentage: 98 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 2 + "True": 98 test-flag399: - percentage: 99 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 1 + "True": 99 test-flag400: - percentage: 0 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 100 + "True": 0 test-flag401: - percentage: 1 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 99 + "True": 1 test-flag402: - percentage: 2 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 98 + "True": 2 test-flag403: - percentage: 3 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 97 + "True": 3 test-flag404: - percentage: 4 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 96 + "True": 4 test-flag405: - percentage: 5 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 95 + "True": 5 test-flag406: - percentage: 6 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 94 + "True": 6 test-flag407: - percentage: 7 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 93 + "True": 7 test-flag408: - percentage: 8 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 92 + "True": 8 test-flag409: - percentage: 9 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 91 + "True": 9 test-flag410: - percentage: 10 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 90 + "True": 10 test-flag411: - percentage: 11 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 89 + "True": 11 test-flag412: - percentage: 12 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 88 + "True": 12 test-flag413: - percentage: 13 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 87 + "True": 13 test-flag414: - percentage: 14 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 86 + "True": 14 test-flag415: - percentage: 15 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 85 + "True": 15 test-flag416: - percentage: 16 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 84 + "True": 16 test-flag417: - percentage: 17 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 83 + "True": 17 test-flag418: - percentage: 18 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 82 + "True": 18 test-flag419: - percentage: 19 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 81 + "True": 19 test-flag420: - percentage: 20 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 80 + "True": 20 test-flag421: - percentage: 21 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 79 + "True": 21 test-flag422: - percentage: 22 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 78 + "True": 22 test-flag423: - percentage: 23 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 77 + "True": 23 test-flag424: - percentage: 24 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 76 + "True": 24 test-flag425: - percentage: 25 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 75 + "True": 25 test-flag426: - percentage: 26 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 74 + "True": 26 test-flag427: - percentage: 27 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 73 + "True": 27 test-flag428: - percentage: 28 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 72 + "True": 28 test-flag429: - percentage: 29 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 71 + "True": 29 test-flag430: - percentage: 30 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 70 + "True": 30 test-flag431: - percentage: 31 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 69 + "True": 31 test-flag432: - percentage: 32 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 68 + "True": 32 test-flag433: - percentage: 33 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 67 + "True": 33 test-flag434: - percentage: 34 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 66 + "True": 34 test-flag435: - percentage: 35 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 65 + "True": 35 test-flag436: - percentage: 36 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 64 + "True": 36 test-flag437: - percentage: 37 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 63 + "True": 37 test-flag438: - percentage: 38 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 62 + "True": 38 test-flag439: - percentage: 39 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 61 + "True": 39 test-flag440: - percentage: 40 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 60 + "True": 40 test-flag441: - percentage: 41 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 59 + "True": 41 test-flag442: - percentage: 42 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 58 + "True": 42 test-flag443: - percentage: 43 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 57 + "True": 43 test-flag444: - percentage: 44 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 56 + "True": 44 test-flag445: - percentage: 45 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 55 + "True": 45 test-flag446: - percentage: 46 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 54 + "True": 46 test-flag447: - percentage: 47 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 53 + "True": 47 test-flag448: - percentage: 48 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 52 + "True": 48 test-flag449: - percentage: 49 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 51 + "True": 49 test-flag450: - percentage: 50 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 50 + "True": 50 test-flag451: - percentage: 51 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 49 + "True": 51 test-flag452: - percentage: 52 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 48 + "True": 52 test-flag453: - percentage: 53 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 47 + "True": 53 test-flag454: - percentage: 54 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 46 + "True": 54 test-flag455: - percentage: 55 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 45 + "True": 55 test-flag456: - percentage: 56 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 44 + "True": 56 test-flag457: - percentage: 57 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 43 + "True": 57 test-flag458: - percentage: 58 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 42 + "True": 58 test-flag459: - percentage: 59 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 41 + "True": 59 test-flag460: - percentage: 60 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 40 + "True": 60 test-flag461: - percentage: 61 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 39 + "True": 61 test-flag462: - percentage: 62 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 38 + "True": 62 test-flag463: - percentage: 63 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 37 + "True": 63 test-flag464: - percentage: 64 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 36 + "True": 64 test-flag465: - percentage: 65 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 35 + "True": 65 test-flag466: - percentage: 66 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 34 + "True": 66 test-flag467: - percentage: 67 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 33 + "True": 67 test-flag468: - percentage: 68 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 32 + "True": 68 test-flag469: - percentage: 69 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 31 + "True": 69 test-flag470: - percentage: 70 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 30 + "True": 70 test-flag471: - percentage: 71 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 29 + "True": 71 test-flag472: - percentage: 72 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 28 + "True": 72 test-flag473: - percentage: 73 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 27 + "True": 73 test-flag474: - percentage: 74 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 26 + "True": 74 test-flag475: - percentage: 75 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 25 + "True": 75 test-flag476: - percentage: 76 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 24 + "True": 76 test-flag477: - percentage: 77 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 23 + "True": 77 test-flag478: - percentage: 78 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 22 + "True": 78 test-flag479: - percentage: 79 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 21 + "True": 79 test-flag480: - percentage: 80 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 20 + "True": 80 test-flag481: - percentage: 81 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 19 + "True": 81 test-flag482: - percentage: 82 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 18 + "True": 82 test-flag483: - percentage: 83 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 17 + "True": 83 test-flag484: - percentage: 84 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 16 + "True": 84 test-flag485: - percentage: 85 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 15 + "True": 85 test-flag486: - percentage: 86 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 14 + "True": 86 test-flag487: - percentage: 87 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 13 + "True": 87 test-flag488: - percentage: 88 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 12 + "True": 88 test-flag489: - percentage: 89 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 11 + "True": 89 test-flag490: - percentage: 90 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 10 + "True": 90 test-flag491: - percentage: 91 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 9 + "True": 91 test-flag492: - percentage: 92 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 8 + "True": 92 test-flag493: - percentage: 93 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 7 + "True": 93 test-flag494: - percentage: 94 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 6 + "True": 94 test-flag495: - percentage: 95 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 5 + "True": 95 test-flag496: - percentage: 96 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 4 + "True": 96 test-flag497: - percentage: 97 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 3 + "True": 97 test-flag498: - percentage: 98 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 2 + "True": 98 test-flag499: - percentage: 99 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 1 + "True": 99 test-flag500: - percentage: 0 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 100 + "True": 0 test-flag501: - percentage: 1 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 99 + "True": 1 test-flag502: - percentage: 2 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 98 + "True": 2 test-flag503: - percentage: 3 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 97 + "True": 3 test-flag504: - percentage: 4 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 96 + "True": 4 test-flag505: - percentage: 5 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 95 + "True": 5 test-flag506: - percentage: 6 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 94 + "True": 6 test-flag507: - percentage: 7 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 93 + "True": 7 test-flag508: - percentage: 8 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 92 + "True": 8 test-flag509: - percentage: 9 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 91 + "True": 9 test-flag510: - percentage: 10 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 90 + "True": 10 test-flag511: - percentage: 11 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 89 + "True": 11 test-flag512: - percentage: 12 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 88 + "True": 12 test-flag513: - percentage: 13 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 87 + "True": 13 test-flag514: - percentage: 14 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 86 + "True": 14 test-flag515: - percentage: 15 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 85 + "True": 15 test-flag516: - percentage: 16 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 84 + "True": 16 test-flag517: - percentage: 17 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 83 + "True": 17 test-flag518: - percentage: 18 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 82 + "True": 18 test-flag519: - percentage: 19 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 81 + "True": 19 test-flag520: - percentage: 20 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 80 + "True": 20 test-flag521: - percentage: 21 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 79 + "True": 21 test-flag522: - percentage: 22 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 78 + "True": 22 test-flag523: - percentage: 23 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 77 + "True": 23 test-flag524: - percentage: 24 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 76 + "True": 24 test-flag525: - percentage: 25 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 75 + "True": 25 test-flag526: - percentage: 26 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 74 + "True": 26 test-flag527: - percentage: 27 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 73 + "True": 27 test-flag528: - percentage: 28 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 72 + "True": 28 test-flag529: - percentage: 29 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 71 + "True": 29 test-flag530: - percentage: 30 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 70 + "True": 30 test-flag531: - percentage: 31 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 69 + "True": 31 test-flag532: - percentage: 32 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 68 + "True": 32 test-flag533: - percentage: 33 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 67 + "True": 33 test-flag534: - percentage: 34 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 66 + "True": 34 test-flag535: - percentage: 35 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 65 + "True": 35 test-flag536: - percentage: 36 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 64 + "True": 36 test-flag537: - percentage: 37 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 63 + "True": 37 test-flag538: - percentage: 38 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 62 + "True": 38 test-flag539: - percentage: 39 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 61 + "True": 39 test-flag540: - percentage: 40 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 60 + "True": 40 test-flag541: - percentage: 41 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 59 + "True": 41 test-flag542: - percentage: 42 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 58 + "True": 42 test-flag543: - percentage: 43 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 57 + "True": 43 test-flag544: - percentage: 44 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 56 + "True": 44 test-flag545: - percentage: 45 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 55 + "True": 45 test-flag546: - percentage: 46 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 54 + "True": 46 test-flag547: - percentage: 47 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 53 + "True": 47 test-flag548: - percentage: 48 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 52 + "True": 48 test-flag549: - percentage: 49 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 51 + "True": 49 test-flag550: - percentage: 50 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 50 + "True": 50 test-flag551: - percentage: 51 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 49 + "True": 51 test-flag552: - percentage: 52 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 48 + "True": 52 test-flag553: - percentage: 53 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 47 + "True": 53 test-flag554: - percentage: 54 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 46 + "True": 54 test-flag555: - percentage: 55 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 45 + "True": 55 test-flag556: - percentage: 56 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 44 + "True": 56 test-flag557: - percentage: 57 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 43 + "True": 57 test-flag558: - percentage: 58 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 42 + "True": 58 test-flag559: - percentage: 59 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 41 + "True": 59 test-flag560: - percentage: 60 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 40 + "True": 60 test-flag561: - percentage: 61 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 39 + "True": 61 test-flag562: - percentage: 62 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 38 + "True": 62 test-flag563: - percentage: 63 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 37 + "True": 63 test-flag564: - percentage: 64 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 36 + "True": 64 test-flag565: - percentage: 65 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 35 + "True": 65 test-flag566: - percentage: 66 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 34 + "True": 66 test-flag567: - percentage: 67 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 33 + "True": 67 test-flag568: - percentage: 68 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 32 + "True": 68 test-flag569: - percentage: 69 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 31 + "True": 69 test-flag570: - percentage: 70 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 30 + "True": 70 test-flag571: - percentage: 71 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 29 + "True": 71 test-flag572: - percentage: 72 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 28 + "True": 72 test-flag573: - percentage: 73 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 27 + "True": 73 test-flag574: - percentage: 74 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 26 + "True": 74 test-flag575: - percentage: 75 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 25 + "True": 75 test-flag576: - percentage: 76 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 24 + "True": 76 test-flag577: - percentage: 77 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 23 + "True": 77 test-flag578: - percentage: 78 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 22 + "True": 78 test-flag579: - percentage: 79 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 21 + "True": 79 test-flag580: - percentage: 80 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 20 + "True": 80 test-flag581: - percentage: 81 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 19 + "True": 81 test-flag582: - percentage: 82 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 18 + "True": 82 test-flag583: - percentage: 83 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 17 + "True": 83 test-flag584: - percentage: 84 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 16 + "True": 84 test-flag585: - percentage: 85 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 15 + "True": 85 test-flag586: - percentage: 86 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 14 + "True": 86 test-flag587: - percentage: 87 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 13 + "True": 87 test-flag588: - percentage: 88 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 12 + "True": 88 test-flag589: - percentage: 89 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 11 + "True": 89 test-flag590: - percentage: 90 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 10 + "True": 90 test-flag591: - percentage: 91 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 9 + "True": 91 test-flag592: - percentage: 92 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 8 + "True": 92 test-flag593: - percentage: 93 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 7 + "True": 93 test-flag594: - percentage: 94 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 6 + "True": 94 test-flag595: - percentage: 95 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 5 + "True": 95 test-flag596: - percentage: 96 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 4 + "True": 96 test-flag597: - percentage: 97 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 3 + "True": 97 test-flag598: - percentage: 98 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 2 + "True": 98 test-flag599: - percentage: 99 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 1 + "True": 99 test-flag600: - percentage: 0 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 100 + "True": 0 test-flag601: - percentage: 1 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 99 + "True": 1 test-flag602: - percentage: 2 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 98 + "True": 2 test-flag603: - percentage: 3 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 97 + "True": 3 test-flag604: - percentage: 4 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 96 + "True": 4 test-flag605: - percentage: 5 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 95 + "True": 5 test-flag606: - percentage: 6 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 94 + "True": 6 test-flag607: - percentage: 7 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 93 + "True": 7 test-flag608: - percentage: 8 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 92 + "True": 8 test-flag609: - percentage: 9 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 91 + "True": 9 test-flag610: - percentage: 10 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 90 + "True": 10 test-flag611: - percentage: 11 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 89 + "True": 11 test-flag612: - percentage: 12 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 88 + "True": 12 test-flag613: - percentage: 13 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 87 + "True": 13 test-flag614: - percentage: 14 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 86 + "True": 14 test-flag615: - percentage: 15 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 85 + "True": 15 test-flag616: - percentage: 16 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 84 + "True": 16 test-flag617: - percentage: 17 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 83 + "True": 17 test-flag618: - percentage: 18 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 82 + "True": 18 test-flag619: - percentage: 19 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 81 + "True": 19 test-flag620: - percentage: 20 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 80 + "True": 20 test-flag621: - percentage: 21 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 79 + "True": 21 test-flag622: - percentage: 22 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 78 + "True": 22 test-flag623: - percentage: 23 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 77 + "True": 23 test-flag624: - percentage: 24 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 76 + "True": 24 test-flag625: - percentage: 25 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 75 + "True": 25 test-flag626: - percentage: 26 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 74 + "True": 26 test-flag627: - percentage: 27 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 73 + "True": 27 test-flag628: - percentage: 28 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 72 + "True": 28 test-flag629: - percentage: 29 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 71 + "True": 29 test-flag630: - percentage: 30 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 70 + "True": 30 test-flag631: - percentage: 31 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 69 + "True": 31 test-flag632: - percentage: 32 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 68 + "True": 32 test-flag633: - percentage: 33 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 67 + "True": 33 test-flag634: - percentage: 34 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 66 + "True": 34 test-flag635: - percentage: 35 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 65 + "True": 35 test-flag636: - percentage: 36 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 64 + "True": 36 test-flag637: - percentage: 37 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 63 + "True": 37 test-flag638: - percentage: 38 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 62 + "True": 38 test-flag639: - percentage: 39 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 61 + "True": 39 test-flag640: - percentage: 40 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 60 + "True": 40 test-flag641: - percentage: 41 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 59 + "True": 41 test-flag642: - percentage: 42 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 58 + "True": 42 test-flag643: - percentage: 43 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 57 + "True": 43 test-flag644: - percentage: 44 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 56 + "True": 44 test-flag645: - percentage: 45 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 55 + "True": 45 test-flag646: - percentage: 46 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 54 + "True": 46 test-flag647: - percentage: 47 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 53 + "True": 47 test-flag648: - percentage: 48 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 52 + "True": 48 test-flag649: - percentage: 49 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 51 + "True": 49 test-flag650: - percentage: 50 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 50 + "True": 50 test-flag651: - percentage: 51 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 49 + "True": 51 test-flag652: - percentage: 52 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 48 + "True": 52 test-flag653: - percentage: 53 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 47 + "True": 53 test-flag654: - percentage: 54 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 46 + "True": 54 test-flag655: - percentage: 55 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 45 + "True": 55 test-flag656: - percentage: 56 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 44 + "True": 56 test-flag657: - percentage: 57 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 43 + "True": 57 test-flag658: - percentage: 58 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 42 + "True": 58 test-flag659: - percentage: 59 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 41 + "True": 59 test-flag660: - percentage: 60 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 40 + "True": 60 test-flag661: - percentage: 61 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 39 + "True": 61 test-flag662: - percentage: 62 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 38 + "True": 62 test-flag663: - percentage: 63 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 37 + "True": 63 test-flag664: - percentage: 64 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 36 + "True": 64 test-flag665: - percentage: 65 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 35 + "True": 65 test-flag666: - percentage: 66 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 34 + "True": 66 test-flag667: - percentage: 67 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 33 + "True": 67 test-flag668: - percentage: 68 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 32 + "True": 68 test-flag669: - percentage: 69 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 31 + "True": 69 test-flag670: - percentage: 70 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 30 + "True": 70 test-flag671: - percentage: 71 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 29 + "True": 71 test-flag672: - percentage: 72 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 28 + "True": 72 test-flag673: - percentage: 73 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 27 + "True": 73 test-flag674: - percentage: 74 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 26 + "True": 74 test-flag675: - percentage: 75 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 25 + "True": 75 test-flag676: - percentage: 76 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 24 + "True": 76 test-flag677: - percentage: 77 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 23 + "True": 77 test-flag678: - percentage: 78 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 22 + "True": 78 test-flag679: - percentage: 79 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 21 + "True": 79 test-flag680: - percentage: 80 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 20 + "True": 80 test-flag681: - percentage: 81 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 19 + "True": 81 test-flag682: - percentage: 82 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 18 + "True": 82 test-flag683: - percentage: 83 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 17 + "True": 83 test-flag684: - percentage: 84 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 16 + "True": 84 test-flag685: - percentage: 85 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 15 + "True": 85 test-flag686: - percentage: 86 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 14 + "True": 86 test-flag687: - percentage: 87 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 13 + "True": 87 test-flag688: - percentage: 88 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 12 + "True": 88 test-flag689: - percentage: 89 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 11 + "True": 89 test-flag690: - percentage: 90 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 10 + "True": 90 test-flag691: - percentage: 91 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 9 + "True": 91 test-flag692: - percentage: 92 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 8 + "True": 92 test-flag693: - percentage: 93 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 7 + "True": 93 test-flag694: - percentage: 94 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 6 + "True": 94 test-flag695: - percentage: 95 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 5 + "True": 95 test-flag696: - percentage: 96 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 4 + "True": 96 test-flag697: - percentage: 97 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 3 + "True": 97 test-flag698: - percentage: 98 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 2 + "True": 98 test-flag699: - percentage: 99 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 1 + "True": 99 test-flag700: - percentage: 0 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 100 + "True": 0 test-flag701: - percentage: 1 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 99 + "True": 1 test-flag702: - percentage: 2 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 98 + "True": 2 test-flag703: - percentage: 3 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 97 + "True": 3 test-flag704: - percentage: 4 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 96 + "True": 4 test-flag705: - percentage: 5 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 95 + "True": 5 test-flag706: - percentage: 6 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 94 + "True": 6 test-flag707: - percentage: 7 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 93 + "True": 7 test-flag708: - percentage: 8 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 92 + "True": 8 test-flag709: - percentage: 9 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 91 + "True": 9 test-flag710: - percentage: 10 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 90 + "True": 10 test-flag711: - percentage: 11 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 89 + "True": 11 test-flag712: - percentage: 12 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 88 + "True": 12 test-flag713: - percentage: 13 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 87 + "True": 13 test-flag714: - percentage: 14 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 86 + "True": 14 test-flag715: - percentage: 15 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 85 + "True": 15 test-flag716: - percentage: 16 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 84 + "True": 16 test-flag717: - percentage: 17 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 83 + "True": 17 test-flag718: - percentage: 18 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 82 + "True": 18 test-flag719: - percentage: 19 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 81 + "True": 19 test-flag720: - percentage: 20 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 80 + "True": 20 test-flag721: - percentage: 21 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 79 + "True": 21 test-flag722: - percentage: 22 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 78 + "True": 22 test-flag723: - percentage: 23 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 77 + "True": 23 test-flag724: - percentage: 24 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 76 + "True": 24 test-flag725: - percentage: 25 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 75 + "True": 25 test-flag726: - percentage: 26 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 74 + "True": 26 test-flag727: - percentage: 27 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 73 + "True": 27 test-flag728: - percentage: 28 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 72 + "True": 28 test-flag729: - percentage: 29 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 71 + "True": 29 test-flag730: - percentage: 30 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 70 + "True": 30 test-flag731: - percentage: 31 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 69 + "True": 31 test-flag732: - percentage: 32 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 68 + "True": 32 test-flag733: - percentage: 33 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 67 + "True": 33 test-flag734: - percentage: 34 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 66 + "True": 34 test-flag735: - percentage: 35 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 65 + "True": 35 test-flag736: - percentage: 36 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 64 + "True": 36 test-flag737: - percentage: 37 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 63 + "True": 37 test-flag738: - percentage: 38 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 62 + "True": 38 test-flag739: - percentage: 39 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 61 + "True": 39 test-flag740: - percentage: 40 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 60 + "True": 40 test-flag741: - percentage: 41 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 59 + "True": 41 test-flag742: - percentage: 42 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 58 + "True": 42 test-flag743: - percentage: 43 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 57 + "True": 43 test-flag744: - percentage: 44 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 56 + "True": 44 test-flag745: - percentage: 45 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 55 + "True": 45 test-flag746: - percentage: 46 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 54 + "True": 46 test-flag747: - percentage: 47 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 53 + "True": 47 test-flag748: - percentage: 48 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 52 + "True": 48 test-flag749: - percentage: 49 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 51 + "True": 49 test-flag750: - percentage: 50 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 50 + "True": 50 test-flag751: - percentage: 51 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 49 + "True": 51 test-flag752: - percentage: 52 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 48 + "True": 52 test-flag753: - percentage: 53 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 47 + "True": 53 test-flag754: - percentage: 54 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 46 + "True": 54 test-flag755: - percentage: 55 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 45 + "True": 55 test-flag756: - percentage: 56 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 44 + "True": 56 test-flag757: - percentage: 57 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 43 + "True": 57 test-flag758: - percentage: 58 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 42 + "True": 58 test-flag759: - percentage: 59 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 41 + "True": 59 test-flag760: - percentage: 60 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 40 + "True": 60 test-flag761: - percentage: 61 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 39 + "True": 61 test-flag762: - percentage: 62 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 38 + "True": 62 test-flag763: - percentage: 63 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 37 + "True": 63 test-flag764: - percentage: 64 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 36 + "True": 64 test-flag765: - percentage: 65 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 35 + "True": 65 test-flag766: - percentage: 66 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 34 + "True": 66 test-flag767: - percentage: 67 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 33 + "True": 67 test-flag768: - percentage: 68 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 32 + "True": 68 test-flag769: - percentage: 69 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 31 + "True": 69 test-flag770: - percentage: 70 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 30 + "True": 70 test-flag771: - percentage: 71 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 29 + "True": 71 test-flag772: - percentage: 72 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 28 + "True": 72 test-flag773: - percentage: 73 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 27 + "True": 73 test-flag774: - percentage: 74 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 26 + "True": 74 test-flag775: - percentage: 75 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 25 + "True": 75 test-flag776: - percentage: 76 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 24 + "True": 76 test-flag777: - percentage: 77 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 23 + "True": 77 test-flag778: - percentage: 78 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 22 + "True": 78 test-flag779: - percentage: 79 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 21 + "True": 79 test-flag780: - percentage: 80 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 20 + "True": 80 test-flag781: - percentage: 81 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 19 + "True": 81 test-flag782: - percentage: 82 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 18 + "True": 82 test-flag783: - percentage: 83 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 17 + "True": 83 test-flag784: - percentage: 84 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 16 + "True": 84 test-flag785: - percentage: 85 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 15 + "True": 85 test-flag786: - percentage: 86 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 14 + "True": 86 test-flag787: - percentage: 87 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 13 + "True": 87 test-flag788: - percentage: 88 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 12 + "True": 88 test-flag789: - percentage: 89 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 11 + "True": 89 test-flag790: - percentage: 90 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 10 + "True": 90 test-flag791: - percentage: 91 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 9 + "True": 91 test-flag792: - percentage: 92 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 8 + "True": 92 test-flag793: - percentage: 93 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 7 + "True": 93 test-flag794: - percentage: 94 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 6 + "True": 94 test-flag795: - percentage: 95 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 5 + "True": 95 test-flag796: - percentage: 96 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 4 + "True": 96 test-flag797: - percentage: 97 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 3 + "True": 97 test-flag798: - percentage: 98 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 2 + "True": 98 test-flag799: - percentage: 99 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 1 + "True": 99 test-flag800: - percentage: 0 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 100 + "True": 0 test-flag801: - percentage: 1 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 99 + "True": 1 test-flag802: - percentage: 2 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 98 + "True": 2 test-flag803: - percentage: 3 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 97 + "True": 3 test-flag804: - percentage: 4 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 96 + "True": 4 test-flag805: - percentage: 5 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 95 + "True": 5 test-flag806: - percentage: 6 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 94 + "True": 6 test-flag807: - percentage: 7 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 93 + "True": 7 test-flag808: - percentage: 8 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 92 + "True": 8 test-flag809: - percentage: 9 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 91 + "True": 9 test-flag810: - percentage: 10 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 90 + "True": 10 test-flag811: - percentage: 11 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 89 + "True": 11 test-flag812: - percentage: 12 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 88 + "True": 12 test-flag813: - percentage: 13 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 87 + "True": 13 test-flag814: - percentage: 14 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 86 + "True": 14 test-flag815: - percentage: 15 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 85 + "True": 15 test-flag816: - percentage: 16 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 84 + "True": 16 test-flag817: - percentage: 17 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 83 + "True": 17 test-flag818: - percentage: 18 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 82 + "True": 18 test-flag819: - percentage: 19 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 81 + "True": 19 test-flag820: - percentage: 20 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 80 + "True": 20 test-flag821: - percentage: 21 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 79 + "True": 21 test-flag822: - percentage: 22 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 78 + "True": 22 test-flag823: - percentage: 23 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 77 + "True": 23 test-flag824: - percentage: 24 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 76 + "True": 24 test-flag825: - percentage: 25 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 75 + "True": 25 test-flag826: - percentage: 26 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 74 + "True": 26 test-flag827: - percentage: 27 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 73 + "True": 27 test-flag828: - percentage: 28 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 72 + "True": 28 test-flag829: - percentage: 29 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 71 + "True": 29 test-flag830: - percentage: 30 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 70 + "True": 30 test-flag831: - percentage: 31 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 69 + "True": 31 test-flag832: - percentage: 32 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 68 + "True": 32 test-flag833: - percentage: 33 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 67 + "True": 33 test-flag834: - percentage: 34 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 66 + "True": 34 test-flag835: - percentage: 35 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 65 + "True": 35 test-flag836: - percentage: 36 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 64 + "True": 36 test-flag837: - percentage: 37 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 63 + "True": 37 test-flag838: - percentage: 38 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 62 + "True": 38 test-flag839: - percentage: 39 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 61 + "True": 39 test-flag840: - percentage: 40 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 60 + "True": 40 test-flag841: - percentage: 41 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 59 + "True": 41 test-flag842: - percentage: 42 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 58 + "True": 42 test-flag843: - percentage: 43 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 57 + "True": 43 test-flag844: - percentage: 44 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 56 + "True": 44 test-flag845: - percentage: 45 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 55 + "True": 45 test-flag846: - percentage: 46 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 54 + "True": 46 test-flag847: - percentage: 47 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 53 + "True": 47 test-flag848: - percentage: 48 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 52 + "True": 48 test-flag849: - percentage: 49 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 51 + "True": 49 test-flag850: - percentage: 50 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 50 + "True": 50 test-flag851: - percentage: 51 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 49 + "True": 51 test-flag852: - percentage: 52 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 48 + "True": 52 test-flag853: - percentage: 53 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 47 + "True": 53 test-flag854: - percentage: 54 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 46 + "True": 54 test-flag855: - percentage: 55 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 45 + "True": 55 test-flag856: - percentage: 56 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 44 + "True": 56 test-flag857: - percentage: 57 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 43 + "True": 57 test-flag858: - percentage: 58 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 42 + "True": 58 test-flag859: - percentage: 59 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 41 + "True": 59 test-flag860: - percentage: 60 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 40 + "True": 60 test-flag861: - percentage: 61 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 39 + "True": 61 test-flag862: - percentage: 62 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 38 + "True": 62 test-flag863: - percentage: 63 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 37 + "True": 63 test-flag864: - percentage: 64 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 36 + "True": 64 test-flag865: - percentage: 65 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 35 + "True": 65 test-flag866: - percentage: 66 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 34 + "True": 66 test-flag867: - percentage: 67 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 33 + "True": 67 test-flag868: - percentage: 68 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 32 + "True": 68 test-flag869: - percentage: 69 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 31 + "True": 69 test-flag870: - percentage: 70 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 30 + "True": 70 test-flag871: - percentage: 71 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 29 + "True": 71 test-flag872: - percentage: 72 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 28 + "True": 72 test-flag873: - percentage: 73 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 27 + "True": 73 test-flag874: - percentage: 74 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 26 + "True": 74 test-flag875: - percentage: 75 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 25 + "True": 75 test-flag876: - percentage: 76 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 24 + "True": 76 test-flag877: - percentage: 77 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 23 + "True": 77 test-flag878: - percentage: 78 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 22 + "True": 78 test-flag879: - percentage: 79 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 21 + "True": 79 test-flag880: - percentage: 80 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 20 + "True": 80 test-flag881: - percentage: 81 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 19 + "True": 81 test-flag882: - percentage: 82 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 18 + "True": 82 test-flag883: - percentage: 83 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 17 + "True": 83 test-flag884: - percentage: 84 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 16 + "True": 84 test-flag885: - percentage: 85 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 15 + "True": 85 test-flag886: - percentage: 86 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 14 + "True": 86 test-flag887: - percentage: 87 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 13 + "True": 87 test-flag888: - percentage: 88 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 12 + "True": 88 test-flag889: - percentage: 89 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 11 + "True": 89 test-flag890: - percentage: 90 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 10 + "True": 90 test-flag891: - percentage: 91 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 9 + "True": 91 test-flag892: - percentage: 92 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 8 + "True": 92 test-flag893: - percentage: 93 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 7 + "True": 93 test-flag894: - percentage: 94 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 6 + "True": 94 test-flag895: - percentage: 95 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 5 + "True": 95 test-flag896: - percentage: 96 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 4 + "True": 96 test-flag897: - percentage: 97 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 3 + "True": 97 test-flag898: - percentage: 98 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 2 + "True": 98 test-flag899: - percentage: 99 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 1 + "True": 99 test-flag900: - percentage: 0 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 100 + "True": 0 test-flag901: - percentage: 1 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 99 + "True": 1 test-flag902: - percentage: 2 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 98 + "True": 2 test-flag903: - percentage: 3 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 97 + "True": 3 test-flag904: - percentage: 4 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 96 + "True": 4 test-flag905: - percentage: 5 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 95 + "True": 5 test-flag906: - percentage: 6 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 94 + "True": 6 test-flag907: - percentage: 7 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 93 + "True": 7 test-flag908: - percentage: 8 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 92 + "True": 8 test-flag909: - percentage: 9 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 91 + "True": 9 test-flag910: - percentage: 10 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 90 + "True": 10 test-flag911: - percentage: 11 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 89 + "True": 11 test-flag912: - percentage: 12 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 88 + "True": 12 test-flag913: - percentage: 13 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 87 + "True": 13 test-flag914: - percentage: 14 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 86 + "True": 14 test-flag915: - percentage: 15 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 85 + "True": 15 test-flag916: - percentage: 16 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 84 + "True": 16 test-flag917: - percentage: 17 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 83 + "True": 17 test-flag918: - percentage: 18 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 82 + "True": 18 test-flag919: - percentage: 19 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 81 + "True": 19 test-flag920: - percentage: 20 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 80 + "True": 20 test-flag921: - percentage: 21 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 79 + "True": 21 test-flag922: - percentage: 22 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 78 + "True": 22 test-flag923: - percentage: 23 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 77 + "True": 23 test-flag924: - percentage: 24 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 76 + "True": 24 test-flag925: - percentage: 25 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 75 + "True": 25 test-flag926: - percentage: 26 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 74 + "True": 26 test-flag927: - percentage: 27 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 73 + "True": 27 test-flag928: - percentage: 28 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 72 + "True": 28 test-flag929: - percentage: 29 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 71 + "True": 29 test-flag930: - percentage: 30 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 70 + "True": 30 test-flag931: - percentage: 31 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 69 + "True": 31 test-flag932: - percentage: 32 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 68 + "True": 32 test-flag933: - percentage: 33 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 67 + "True": 33 test-flag934: - percentage: 34 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 66 + "True": 34 test-flag935: - percentage: 35 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 65 + "True": 35 test-flag936: - percentage: 36 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 64 + "True": 36 test-flag937: - percentage: 37 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 63 + "True": 37 test-flag938: - percentage: 38 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 62 + "True": 38 test-flag939: - percentage: 39 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 61 + "True": 39 test-flag940: - percentage: 40 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 60 + "True": 40 test-flag941: - percentage: 41 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 59 + "True": 41 test-flag942: - percentage: 42 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 58 + "True": 42 test-flag943: - percentage: 43 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 57 + "True": 43 test-flag944: - percentage: 44 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 56 + "True": 44 test-flag945: - percentage: 45 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 55 + "True": 45 test-flag946: - percentage: 46 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 54 + "True": 46 test-flag947: - percentage: 47 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 53 + "True": 47 test-flag948: - percentage: 48 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 52 + "True": 48 test-flag949: - percentage: 49 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 51 + "True": 49 test-flag950: - percentage: 50 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 50 + "True": 50 test-flag951: - percentage: 51 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 49 + "True": 51 test-flag952: - percentage: 52 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 48 + "True": 52 test-flag953: - percentage: 53 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 47 + "True": 53 test-flag954: - percentage: 54 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 46 + "True": 54 test-flag955: - percentage: 55 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 45 + "True": 55 test-flag956: - percentage: 56 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 44 + "True": 56 test-flag957: - percentage: 57 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 43 + "True": 57 test-flag958: - percentage: 58 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 42 + "True": 58 test-flag959: - percentage: 59 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 41 + "True": 59 test-flag960: - percentage: 60 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 40 + "True": 60 test-flag961: - percentage: 61 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 39 + "True": 61 test-flag962: - percentage: 62 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 38 + "True": 62 test-flag963: - percentage: 63 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 37 + "True": 63 test-flag964: - percentage: 64 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 36 + "True": 64 test-flag965: - percentage: 65 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 35 + "True": 65 test-flag966: - percentage: 66 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 34 + "True": 66 test-flag967: - percentage: 67 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 33 + "True": 67 test-flag968: - percentage: 68 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 32 + "True": 68 test-flag969: - percentage: 69 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 31 + "True": 69 test-flag970: - percentage: 70 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 30 + "True": 70 test-flag971: - percentage: 71 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 29 + "True": 71 test-flag972: - percentage: 72 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 28 + "True": 72 test-flag973: - percentage: 73 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 27 + "True": 73 test-flag974: - percentage: 74 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 26 + "True": 74 test-flag975: - percentage: 75 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 25 + "True": 75 test-flag976: - percentage: 76 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 24 + "True": 76 test-flag977: - percentage: 77 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 23 + "True": 77 test-flag978: - percentage: 78 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 22 + "True": 78 test-flag979: - percentage: 79 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 21 + "True": 79 test-flag980: - percentage: 80 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 20 + "True": 80 test-flag981: - percentage: 81 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 19 + "True": 81 test-flag982: - percentage: 82 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 18 + "True": 82 test-flag983: - percentage: 83 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 17 + "True": 83 test-flag984: - percentage: 84 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 16 + "True": 84 test-flag985: - percentage: 85 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 15 + "True": 85 test-flag986: - percentage: 86 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 14 + "True": 86 test-flag987: - percentage: 87 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 13 + "True": 87 test-flag988: - percentage: 88 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 12 + "True": 88 test-flag989: - percentage: 89 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 11 + "True": 89 test-flag990: - percentage: 90 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 10 + "True": 90 test-flag991: - percentage: 91 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 9 + "True": 91 test-flag992: - percentage: 92 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 8 + "True": 92 test-flag993: - percentage: 93 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 7 + "True": 93 test-flag994: - percentage: 94 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 6 + "True": 94 test-flag995: - percentage: 95 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 5 + "True": 95 test-flag996: - percentage: 96 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 4 + "True": 96 test-flag997: - percentage: 97 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 3 + "True": 97 test-flag998: - percentage: 98 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 2 + "True": 98 test-flag999: - percentage: 99 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 1 + "True": 99 test-flag1000: - percentage: 0 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 100 + "True": 0 test-flag1001: - percentage: 1 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 99 + "True": 1 test-flag1002: - percentage: 2 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 98 + "True": 2 test-flag1003: - percentage: 3 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 97 + "True": 3 test-flag1004: - percentage: 4 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 96 + "True": 4 test-flag1005: - percentage: 5 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 95 + "True": 5 test-flag1006: - percentage: 6 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 94 + "True": 6 test-flag1007: - percentage: 7 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 93 + "True": 7 test-flag1008: - percentage: 8 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 92 + "True": 8 test-flag1009: - percentage: 9 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 91 + "True": 9 test-flag1010: - percentage: 10 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 90 + "True": 10 test-flag1011: - percentage: 11 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 89 + "True": 11 test-flag1012: - percentage: 12 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 88 + "True": 12 test-flag1013: - percentage: 13 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 87 + "True": 13 test-flag1014: - percentage: 14 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 86 + "True": 14 test-flag1015: - percentage: 15 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 85 + "True": 15 test-flag1016: - percentage: 16 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 84 + "True": 16 test-flag1017: - percentage: 17 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 83 + "True": 17 test-flag1018: - percentage: 18 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 82 + "True": 18 test-flag1019: - percentage: 19 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 81 + "True": 19 test-flag1020: - percentage: 20 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 80 + "True": 20 test-flag1021: - percentage: 21 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 79 + "True": 21 test-flag1022: - percentage: 22 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 78 + "True": 22 test-flag1023: - percentage: 23 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 77 + "True": 23 test-flag1024: - percentage: 24 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 76 + "True": 24 test-flag1025: - percentage: 25 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 75 + "True": 25 test-flag1026: - percentage: 26 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 74 + "True": 26 test-flag1027: - percentage: 27 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 73 + "True": 27 test-flag1028: - percentage: 28 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 72 + "True": 28 test-flag1029: - percentage: 29 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 71 + "True": 29 test-flag1030: - percentage: 30 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 70 + "True": 30 test-flag1031: - percentage: 31 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 69 + "True": 31 test-flag1032: - percentage: 32 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 68 + "True": 32 test-flag1033: - percentage: 33 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 67 + "True": 33 test-flag1034: - percentage: 34 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 66 + "True": 34 test-flag1035: - percentage: 35 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 65 + "True": 35 test-flag1036: - percentage: 36 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 64 + "True": 36 test-flag1037: - percentage: 37 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 63 + "True": 37 test-flag1038: - percentage: 38 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 62 + "True": 38 test-flag1039: - percentage: 39 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 61 + "True": 39 test-flag1040: - percentage: 40 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 60 + "True": 40 test-flag1041: - percentage: 41 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 59 + "True": 41 test-flag1042: - percentage: 42 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 58 + "True": 42 test-flag1043: - percentage: 43 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 57 + "True": 43 test-flag1044: - percentage: 44 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 56 + "True": 44 test-flag1045: - percentage: 45 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 55 + "True": 45 test-flag1046: - percentage: 46 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 54 + "True": 46 test-flag1047: - percentage: 47 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 53 + "True": 47 test-flag1048: - percentage: 48 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 52 + "True": 48 test-flag1049: - percentage: 49 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 51 + "True": 49 test-flag1050: - percentage: 50 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 50 + "True": 50 test-flag1051: - percentage: 51 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 49 + "True": 51 test-flag1052: - percentage: 52 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 48 + "True": 52 test-flag1053: - percentage: 53 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 47 + "True": 53 test-flag1054: - percentage: 54 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 46 + "True": 54 test-flag1055: - percentage: 55 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 45 + "True": 55 test-flag1056: - percentage: 56 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 44 + "True": 56 test-flag1057: - percentage: 57 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 43 + "True": 57 test-flag1058: - percentage: 58 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 42 + "True": 58 test-flag1059: - percentage: 59 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 41 + "True": 59 test-flag1060: - percentage: 60 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 40 + "True": 60 test-flag1061: - percentage: 61 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 39 + "True": 61 test-flag1062: - percentage: 62 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 38 + "True": 62 test-flag1063: - percentage: 63 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 37 + "True": 63 test-flag1064: - percentage: 64 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 36 + "True": 64 test-flag1065: - percentage: 65 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 35 + "True": 65 test-flag1066: - percentage: 66 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 34 + "True": 66 test-flag1067: - percentage: 67 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 33 + "True": 67 test-flag1068: - percentage: 68 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 32 + "True": 68 test-flag1069: - percentage: 69 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 31 + "True": 69 test-flag1070: - percentage: 70 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 30 + "True": 70 test-flag1071: - percentage: 71 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 29 + "True": 71 test-flag1072: - percentage: 72 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 28 + "True": 72 test-flag1073: - percentage: 73 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 27 + "True": 73 test-flag1074: - percentage: 74 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 26 + "True": 74 test-flag1075: - percentage: 75 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 25 + "True": 75 test-flag1076: - percentage: 76 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 24 + "True": 76 test-flag1077: - percentage: 77 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 23 + "True": 77 test-flag1078: - percentage: 78 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 22 + "True": 78 test-flag1079: - percentage: 79 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 21 + "True": 79 test-flag1080: - percentage: 80 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 20 + "True": 80 test-flag1081: - percentage: 81 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 19 + "True": 81 test-flag1082: - percentage: 82 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 18 + "True": 82 test-flag1083: - percentage: 83 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 17 + "True": 83 test-flag1084: - percentage: 84 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 16 + "True": 84 test-flag1085: - percentage: 85 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 15 + "True": 85 test-flag1086: - percentage: 86 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 14 + "True": 86 test-flag1087: - percentage: 87 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 13 + "True": 87 test-flag1088: - percentage: 88 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 12 + "True": 88 test-flag1089: - percentage: 89 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 11 + "True": 89 test-flag1090: - percentage: 90 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 10 + "True": 90 test-flag1091: - percentage: 91 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 9 + "True": 91 test-flag1092: - percentage: 92 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 8 + "True": 92 test-flag1093: - percentage: 93 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 7 + "True": 93 test-flag1094: - percentage: 94 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 6 + "True": 94 test-flag1095: - percentage: 95 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 5 + "True": 95 test-flag1096: - percentage: 96 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 4 + "True": 96 test-flag1097: - percentage: 97 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 3 + "True": 97 test-flag1098: - percentage: 98 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 2 + "True": 98 test-flag1099: - percentage: 99 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 1 + "True": 99 test-flag1100: - percentage: 0 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 100 + "True": 0 test-flag1101: - percentage: 1 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 99 + "True": 1 test-flag1102: - percentage: 2 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 98 + "True": 2 test-flag1103: - percentage: 3 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 97 + "True": 3 test-flag1104: - percentage: 4 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 96 + "True": 4 test-flag1105: - percentage: 5 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 95 + "True": 5 test-flag1106: - percentage: 6 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 94 + "True": 6 test-flag1107: - percentage: 7 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 93 + "True": 7 test-flag1108: - percentage: 8 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 92 + "True": 8 test-flag1109: - percentage: 9 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 91 + "True": 9 test-flag1110: - percentage: 10 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 90 + "True": 10 test-flag1111: - percentage: 11 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 89 + "True": 11 test-flag1112: - percentage: 12 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 88 + "True": 12 test-flag1113: - percentage: 13 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 87 + "True": 13 test-flag1114: - percentage: 14 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 86 + "True": 14 test-flag1115: - percentage: 15 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 85 + "True": 15 test-flag1116: - percentage: 16 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 84 + "True": 16 test-flag1117: - percentage: 17 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 83 + "True": 17 test-flag1118: - percentage: 18 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 82 + "True": 18 test-flag1119: - percentage: 19 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 81 + "True": 19 test-flag1120: - percentage: 20 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 80 + "True": 20 test-flag1121: - percentage: 21 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 79 + "True": 21 test-flag1122: - percentage: 22 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 78 + "True": 22 test-flag1123: - percentage: 23 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 77 + "True": 23 test-flag1124: - percentage: 24 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 76 + "True": 24 test-flag1125: - percentage: 25 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 75 + "True": 25 test-flag1126: - percentage: 26 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 74 + "True": 26 test-flag1127: - percentage: 27 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 73 + "True": 27 test-flag1128: - percentage: 28 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 72 + "True": 28 test-flag1129: - percentage: 29 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 71 + "True": 29 test-flag1130: - percentage: 30 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 70 + "True": 30 test-flag1131: - percentage: 31 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 69 + "True": 31 test-flag1132: - percentage: 32 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 68 + "True": 32 test-flag1133: - percentage: 33 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 67 + "True": 33 test-flag1134: - percentage: 34 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 66 + "True": 34 test-flag1135: - percentage: 35 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 65 + "True": 35 test-flag1136: - percentage: 36 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 64 + "True": 36 test-flag1137: - percentage: 37 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 63 + "True": 37 test-flag1138: - percentage: 38 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 62 + "True": 38 test-flag1139: - percentage: 39 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 61 + "True": 39 test-flag1140: - percentage: 40 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 60 + "True": 40 test-flag1141: - percentage: 41 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 59 + "True": 41 test-flag1142: - percentage: 42 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 58 + "True": 42 test-flag1143: - percentage: 43 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 57 + "True": 43 test-flag1144: - percentage: 44 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 56 + "True": 44 test-flag1145: - percentage: 45 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 55 + "True": 45 test-flag1146: - percentage: 46 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 54 + "True": 46 test-flag1147: - percentage: 47 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 53 + "True": 47 test-flag1148: - percentage: 48 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 52 + "True": 48 test-flag1149: - percentage: 49 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 51 + "True": 49 test-flag1150: - percentage: 50 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 50 + "True": 50 test-flag1151: - percentage: 51 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 49 + "True": 51 test-flag1152: - percentage: 52 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 48 + "True": 52 test-flag1153: - percentage: 53 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 47 + "True": 53 test-flag1154: - percentage: 54 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 46 + "True": 54 test-flag1155: - percentage: 55 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 45 + "True": 55 test-flag1156: - percentage: 56 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 44 + "True": 56 test-flag1157: - percentage: 57 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 43 + "True": 57 test-flag1158: - percentage: 58 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 42 + "True": 58 test-flag1159: - percentage: 59 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 41 + "True": 59 test-flag1160: - percentage: 60 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 40 + "True": 60 test-flag1161: - percentage: 61 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 39 + "True": 61 test-flag1162: - percentage: 62 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 38 + "True": 62 test-flag1163: - percentage: 63 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 37 + "True": 63 test-flag1164: - percentage: 64 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 36 + "True": 64 test-flag1165: - percentage: 65 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 35 + "True": 65 test-flag1166: - percentage: 66 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 34 + "True": 66 test-flag1167: - percentage: 67 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 33 + "True": 67 test-flag1168: - percentage: 68 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 32 + "True": 68 test-flag1169: - percentage: 69 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 31 + "True": 69 test-flag1170: - percentage: 70 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 30 + "True": 70 test-flag1171: - percentage: 71 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 29 + "True": 71 test-flag1172: - percentage: 72 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 28 + "True": 72 test-flag1173: - percentage: 73 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 27 + "True": 73 test-flag1174: - percentage: 74 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 26 + "True": 74 test-flag1175: - percentage: 75 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 25 + "True": 75 test-flag1176: - percentage: 76 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 24 + "True": 76 test-flag1177: - percentage: 77 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 23 + "True": 77 test-flag1178: - percentage: 78 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 22 + "True": 78 test-flag1179: - percentage: 79 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 21 + "True": 79 test-flag1180: - percentage: 80 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 20 + "True": 80 test-flag1181: - percentage: 81 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 19 + "True": 81 test-flag1182: - percentage: 82 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 18 + "True": 82 test-flag1183: - percentage: 83 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 17 + "True": 83 test-flag1184: - percentage: 84 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 16 + "True": 84 test-flag1185: - percentage: 85 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 15 + "True": 85 test-flag1186: - percentage: 86 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 14 + "True": 86 test-flag1187: - percentage: 87 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 13 + "True": 87 test-flag1188: - percentage: 88 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 12 + "True": 88 test-flag1189: - percentage: 89 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 11 + "True": 89 test-flag1190: - percentage: 90 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 10 + "True": 90 test-flag1191: - percentage: 91 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 9 + "True": 91 test-flag1192: - percentage: 92 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 8 + "True": 92 test-flag1193: - percentage: 93 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 7 + "True": 93 test-flag1194: - percentage: 94 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 6 + "True": 94 test-flag1195: - percentage: 95 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 5 + "True": 95 test-flag1196: - percentage: 96 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 4 + "True": 96 test-flag1197: - percentage: 97 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 3 + "True": 97 test-flag1198: - percentage: 98 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 2 + "True": 98 test-flag1199: - percentage: 99 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 1 + "True": 99 test-flag1200: - percentage: 0 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 100 + "True": 0 test-flag1201: - percentage: 1 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 99 + "True": 1 test-flag1202: - percentage: 2 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 98 + "True": 2 test-flag1203: - percentage: 3 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 97 + "True": 3 test-flag1204: - percentage: 4 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 96 + "True": 4 test-flag1205: - percentage: 5 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 95 + "True": 5 test-flag1206: - percentage: 6 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 94 + "True": 6 test-flag1207: - percentage: 7 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 93 + "True": 7 test-flag1208: - percentage: 8 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 92 + "True": 8 test-flag1209: - percentage: 9 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 91 + "True": 9 test-flag1210: - percentage: 10 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 90 + "True": 10 test-flag1211: - percentage: 11 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 89 + "True": 11 test-flag1212: - percentage: 12 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 88 + "True": 12 test-flag1213: - percentage: 13 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 87 + "True": 13 test-flag1214: - percentage: 14 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 86 + "True": 14 test-flag1215: - percentage: 15 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 85 + "True": 15 test-flag1216: - percentage: 16 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 84 + "True": 16 test-flag1217: - percentage: 17 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 83 + "True": 17 test-flag1218: - percentage: 18 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 82 + "True": 18 test-flag1219: - percentage: 19 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 81 + "True": 19 test-flag1220: - percentage: 20 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 80 + "True": 20 test-flag1221: - percentage: 21 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 79 + "True": 21 test-flag1222: - percentage: 22 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 78 + "True": 22 test-flag1223: - percentage: 23 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 77 + "True": 23 test-flag1224: - percentage: 24 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 76 + "True": 24 test-flag1225: - percentage: 25 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 75 + "True": 25 test-flag1226: - percentage: 26 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 74 + "True": 26 test-flag1227: - percentage: 27 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 73 + "True": 27 test-flag1228: - percentage: 28 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 72 + "True": 28 test-flag1229: - percentage: 29 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 71 + "True": 29 test-flag1230: - percentage: 30 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 70 + "True": 30 test-flag1231: - percentage: 31 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 69 + "True": 31 test-flag1232: - percentage: 32 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 68 + "True": 32 test-flag1233: - percentage: 33 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 67 + "True": 33 test-flag1234: - percentage: 34 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 66 + "True": 34 test-flag1235: - percentage: 35 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 65 + "True": 35 test-flag1236: - percentage: 36 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 64 + "True": 36 test-flag1237: - percentage: 37 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 63 + "True": 37 test-flag1238: - percentage: 38 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 62 + "True": 38 test-flag1239: - percentage: 39 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 61 + "True": 39 test-flag1240: - percentage: 40 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 60 + "True": 40 test-flag1241: - percentage: 41 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 59 + "True": 41 test-flag1242: - percentage: 42 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 58 + "True": 42 test-flag1243: - percentage: 43 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 57 + "True": 43 test-flag1244: - percentage: 44 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 56 + "True": 44 test-flag1245: - percentage: 45 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 55 + "True": 45 test-flag1246: - percentage: 46 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 54 + "True": 46 test-flag1247: - percentage: 47 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 53 + "True": 47 test-flag1248: - percentage: 48 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 52 + "True": 48 test-flag1249: - percentage: 49 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 51 + "True": 49 test-flag1250: - percentage: 50 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 50 + "True": 50 test-flag1251: - percentage: 51 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 49 + "True": 51 test-flag1252: - percentage: 52 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 48 + "True": 52 test-flag1253: - percentage: 53 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 47 + "True": 53 test-flag1254: - percentage: 54 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 46 + "True": 54 test-flag1255: - percentage: 55 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 45 + "True": 55 test-flag1256: - percentage: 56 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 44 + "True": 56 test-flag1257: - percentage: 57 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 43 + "True": 57 test-flag1258: - percentage: 58 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 42 + "True": 58 test-flag1259: - percentage: 59 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 41 + "True": 59 test-flag1260: - percentage: 60 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 40 + "True": 60 test-flag1261: - percentage: 61 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 39 + "True": 61 test-flag1262: - percentage: 62 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 38 + "True": 62 test-flag1263: - percentage: 63 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 37 + "True": 63 test-flag1264: - percentage: 64 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 36 + "True": 64 test-flag1265: - percentage: 65 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 35 + "True": 65 test-flag1266: - percentage: 66 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 34 + "True": 66 test-flag1267: - percentage: 67 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 33 + "True": 67 test-flag1268: - percentage: 68 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 32 + "True": 68 test-flag1269: - percentage: 69 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 31 + "True": 69 test-flag1270: - percentage: 70 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 30 + "True": 70 test-flag1271: - percentage: 71 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 29 + "True": 71 test-flag1272: - percentage: 72 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 28 + "True": 72 test-flag1273: - percentage: 73 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 27 + "True": 73 test-flag1274: - percentage: 74 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 26 + "True": 74 test-flag1275: - percentage: 75 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 25 + "True": 75 test-flag1276: - percentage: 76 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 24 + "True": 76 test-flag1277: - percentage: 77 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 23 + "True": 77 test-flag1278: - percentage: 78 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 22 + "True": 78 test-flag1279: - percentage: 79 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 21 + "True": 79 test-flag1280: - percentage: 80 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 20 + "True": 80 test-flag1281: - percentage: 81 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 19 + "True": 81 test-flag1282: - percentage: 82 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 18 + "True": 82 test-flag1283: - percentage: 83 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 17 + "True": 83 test-flag1284: - percentage: 84 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 16 + "True": 84 test-flag1285: - percentage: 85 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 15 + "True": 85 test-flag1286: - percentage: 86 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 14 + "True": 86 test-flag1287: - percentage: 87 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 13 + "True": 87 test-flag1288: - percentage: 88 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 12 + "True": 88 test-flag1289: - percentage: 89 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 11 + "True": 89 test-flag1290: - percentage: 90 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 10 + "True": 90 test-flag1291: - percentage: 91 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 9 + "True": 91 test-flag1292: - percentage: 92 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 8 + "True": 92 test-flag1293: - percentage: 93 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 7 + "True": 93 test-flag1294: - percentage: 94 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 6 + "True": 94 test-flag1295: - percentage: 95 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 5 + "True": 95 test-flag1296: - percentage: 96 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 4 + "True": 96 test-flag1297: - percentage: 97 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 3 + "True": 97 test-flag1298: - percentage: 98 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 2 + "True": 98 test-flag1299: - percentage: 99 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 1 + "True": 99 test-flag1300: - percentage: 0 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 100 + "True": 0 test-flag1301: - percentage: 1 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 99 + "True": 1 test-flag1302: - percentage: 2 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 98 + "True": 2 test-flag1303: - percentage: 3 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 97 + "True": 3 test-flag1304: - percentage: 4 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 96 + "True": 4 test-flag1305: - percentage: 5 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 95 + "True": 5 test-flag1306: - percentage: 6 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 94 + "True": 6 test-flag1307: - percentage: 7 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 93 + "True": 7 test-flag1308: - percentage: 8 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 92 + "True": 8 test-flag1309: - percentage: 9 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 91 + "True": 9 test-flag1310: - percentage: 10 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 90 + "True": 10 test-flag1311: - percentage: 11 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 89 + "True": 11 test-flag1312: - percentage: 12 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 88 + "True": 12 test-flag1313: - percentage: 13 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 87 + "True": 13 test-flag1314: - percentage: 14 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 86 + "True": 14 test-flag1315: - percentage: 15 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 85 + "True": 15 test-flag1316: - percentage: 16 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 84 + "True": 16 test-flag1317: - percentage: 17 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 83 + "True": 17 test-flag1318: - percentage: 18 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 82 + "True": 18 test-flag1319: - percentage: 19 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 81 + "True": 19 test-flag1320: - percentage: 20 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 80 + "True": 20 test-flag1321: - percentage: 21 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 79 + "True": 21 test-flag1322: - percentage: 22 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 78 + "True": 22 test-flag1323: - percentage: 23 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 77 + "True": 23 test-flag1324: - percentage: 24 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 76 + "True": 24 test-flag1325: - percentage: 25 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 75 + "True": 25 test-flag1326: - percentage: 26 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 74 + "True": 26 test-flag1327: - percentage: 27 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 73 + "True": 27 test-flag1328: - percentage: 28 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 72 + "True": 28 test-flag1329: - percentage: 29 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 71 + "True": 29 test-flag1330: - percentage: 30 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 70 + "True": 30 test-flag1331: - percentage: 31 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 69 + "True": 31 test-flag1332: - percentage: 32 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 68 + "True": 32 test-flag1333: - percentage: 33 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 67 + "True": 33 test-flag1334: - percentage: 34 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 66 + "True": 34 test-flag1335: - percentage: 35 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 65 + "True": 35 test-flag1336: - percentage: 36 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 64 + "True": 36 test-flag1337: - percentage: 37 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 63 + "True": 37 test-flag1338: - percentage: 38 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 62 + "True": 38 test-flag1339: - percentage: 39 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 61 + "True": 39 test-flag1340: - percentage: 40 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 60 + "True": 40 test-flag1341: - percentage: 41 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 59 + "True": 41 test-flag1342: - percentage: 42 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 58 + "True": 42 test-flag1343: - percentage: 43 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 57 + "True": 43 test-flag1344: - percentage: 44 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 56 + "True": 44 test-flag1345: - percentage: 45 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 55 + "True": 45 test-flag1346: - percentage: 46 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 54 + "True": 46 test-flag1347: - percentage: 47 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 53 + "True": 47 test-flag1348: - percentage: 48 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 52 + "True": 48 test-flag1349: - percentage: 49 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 51 + "True": 49 test-flag1350: - percentage: 50 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 50 + "True": 50 test-flag1351: - percentage: 51 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 49 + "True": 51 test-flag1352: - percentage: 52 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 48 + "True": 52 test-flag1353: - percentage: 53 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 47 + "True": 53 test-flag1354: - percentage: 54 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 46 + "True": 54 test-flag1355: - percentage: 55 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 45 + "True": 55 test-flag1356: - percentage: 56 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 44 + "True": 56 test-flag1357: - percentage: 57 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 43 + "True": 57 test-flag1358: - percentage: 58 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 42 + "True": 58 test-flag1359: - percentage: 59 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 41 + "True": 59 test-flag1360: - percentage: 60 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 40 + "True": 60 test-flag1361: - percentage: 61 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 39 + "True": 61 test-flag1362: - percentage: 62 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 38 + "True": 62 test-flag1363: - percentage: 63 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 37 + "True": 63 test-flag1364: - percentage: 64 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 36 + "True": 64 test-flag1365: - percentage: 65 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 35 + "True": 65 test-flag1366: - percentage: 66 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 34 + "True": 66 test-flag1367: - percentage: 67 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 33 + "True": 67 test-flag1368: - percentage: 68 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 32 + "True": 68 test-flag1369: - percentage: 69 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 31 + "True": 69 test-flag1370: - percentage: 70 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 30 + "True": 70 test-flag1371: - percentage: 71 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 29 + "True": 71 test-flag1372: - percentage: 72 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 28 + "True": 72 test-flag1373: - percentage: 73 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 27 + "True": 73 test-flag1374: - percentage: 74 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 26 + "True": 74 test-flag1375: - percentage: 75 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 25 + "True": 75 test-flag1376: - percentage: 76 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 24 + "True": 76 test-flag1377: - percentage: 77 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 23 + "True": 77 test-flag1378: - percentage: 78 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 22 + "True": 78 test-flag1379: - percentage: 79 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 21 + "True": 79 test-flag1380: - percentage: 80 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 20 + "True": 80 test-flag1381: - percentage: 81 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 19 + "True": 81 test-flag1382: - percentage: 82 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 18 + "True": 82 test-flag1383: - percentage: 83 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 17 + "True": 83 test-flag1384: - percentage: 84 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 16 + "True": 84 test-flag1385: - percentage: 85 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 15 + "True": 85 test-flag1386: - percentage: 86 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 14 + "True": 86 test-flag1387: - percentage: 87 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 13 + "True": 87 test-flag1388: - percentage: 88 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 12 + "True": 88 test-flag1389: - percentage: 89 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 11 + "True": 89 test-flag1390: - percentage: 90 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 10 + "True": 90 test-flag1391: - percentage: 91 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 9 + "True": 91 test-flag1392: - percentage: 92 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 8 + "True": 92 test-flag1393: - percentage: 93 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 7 + "True": 93 test-flag1394: - percentage: 94 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 6 + "True": 94 test-flag1395: - percentage: 95 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 5 + "True": 95 test-flag1396: - percentage: 96 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 4 + "True": 96 test-flag1397: - percentage: 97 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 3 + "True": 97 test-flag1398: - percentage: 98 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 2 + "True": 98 test-flag1399: - percentage: 99 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 1 + "True": 99 test-flag1400: - percentage: 0 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 100 + "True": 0 test-flag1401: - percentage: 1 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 99 + "True": 1 test-flag1402: - percentage: 2 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 98 + "True": 2 test-flag1403: - percentage: 3 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 97 + "True": 3 test-flag1404: - percentage: 4 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 96 + "True": 4 test-flag1405: - percentage: 5 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 95 + "True": 5 test-flag1406: - percentage: 6 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 94 + "True": 6 test-flag1407: - percentage: 7 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 93 + "True": 7 test-flag1408: - percentage: 8 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 92 + "True": 8 test-flag1409: - percentage: 9 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 91 + "True": 9 test-flag1410: - percentage: 10 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 90 + "True": 10 test-flag1411: - percentage: 11 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 89 + "True": 11 test-flag1412: - percentage: 12 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 88 + "True": 12 test-flag1413: - percentage: 13 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 87 + "True": 13 test-flag1414: - percentage: 14 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 86 + "True": 14 test-flag1415: - percentage: 15 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 85 + "True": 15 test-flag1416: - percentage: 16 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 84 + "True": 16 test-flag1417: - percentage: 17 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 83 + "True": 17 test-flag1418: - percentage: 18 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 82 + "True": 18 test-flag1419: - percentage: 19 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 81 + "True": 19 test-flag1420: - percentage: 20 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 80 + "True": 20 test-flag1421: - percentage: 21 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 79 + "True": 21 test-flag1422: - percentage: 22 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 78 + "True": 22 test-flag1423: - percentage: 23 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 77 + "True": 23 test-flag1424: - percentage: 24 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 76 + "True": 24 test-flag1425: - percentage: 25 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 75 + "True": 25 test-flag1426: - percentage: 26 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 74 + "True": 26 test-flag1427: - percentage: 27 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 73 + "True": 27 test-flag1428: - percentage: 28 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 72 + "True": 28 test-flag1429: - percentage: 29 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 71 + "True": 29 test-flag1430: - percentage: 30 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 70 + "True": 30 test-flag1431: - percentage: 31 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 69 + "True": 31 test-flag1432: - percentage: 32 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 68 + "True": 32 test-flag1433: - percentage: 33 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 67 + "True": 33 test-flag1434: - percentage: 34 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 66 + "True": 34 test-flag1435: - percentage: 35 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 65 + "True": 35 test-flag1436: - percentage: 36 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 64 + "True": 36 test-flag1437: - percentage: 37 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 63 + "True": 37 test-flag1438: - percentage: 38 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 62 + "True": 38 test-flag1439: - percentage: 39 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 61 + "True": 39 test-flag1440: - percentage: 40 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 60 + "True": 40 test-flag1441: - percentage: 41 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 59 + "True": 41 test-flag1442: - percentage: 42 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 58 + "True": 42 test-flag1443: - percentage: 43 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 57 + "True": 43 test-flag1444: - percentage: 44 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 56 + "True": 44 test-flag1445: - percentage: 45 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 55 + "True": 45 test-flag1446: - percentage: 46 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 54 + "True": 46 test-flag1447: - percentage: 47 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 53 + "True": 47 test-flag1448: - percentage: 48 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 52 + "True": 48 test-flag1449: - percentage: 49 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 51 + "True": 49 test-flag1450: - percentage: 50 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 50 + "True": 50 test-flag1451: - percentage: 51 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 49 + "True": 51 test-flag1452: - percentage: 52 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 48 + "True": 52 test-flag1453: - percentage: 53 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 47 + "True": 53 test-flag1454: - percentage: 54 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 46 + "True": 54 test-flag1455: - percentage: 55 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 45 + "True": 55 test-flag1456: - percentage: 56 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 44 + "True": 56 test-flag1457: - percentage: 57 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 43 + "True": 57 test-flag1458: - percentage: 58 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 42 + "True": 58 test-flag1459: - percentage: 59 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 41 + "True": 59 test-flag1460: - percentage: 60 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 40 + "True": 60 test-flag1461: - percentage: 61 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 39 + "True": 61 test-flag1462: - percentage: 62 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 38 + "True": 62 test-flag1463: - percentage: 63 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 37 + "True": 63 test-flag1464: - percentage: 64 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 36 + "True": 64 test-flag1465: - percentage: 65 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 35 + "True": 65 test-flag1466: - percentage: 66 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 34 + "True": 66 test-flag1467: - percentage: 67 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 33 + "True": 67 test-flag1468: - percentage: 68 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 32 + "True": 68 test-flag1469: - percentage: 69 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 31 + "True": 69 test-flag1470: - percentage: 70 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 30 + "True": 70 test-flag1471: - percentage: 71 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 29 + "True": 71 test-flag1472: - percentage: 72 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 28 + "True": 72 test-flag1473: - percentage: 73 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 27 + "True": 73 test-flag1474: - percentage: 74 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 26 + "True": 74 test-flag1475: - percentage: 75 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 25 + "True": 75 test-flag1476: - percentage: 76 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 24 + "True": 76 test-flag1477: - percentage: 77 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 23 + "True": 77 test-flag1478: - percentage: 78 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 22 + "True": 78 test-flag1479: - percentage: 79 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 21 + "True": 79 test-flag1480: - percentage: 80 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 20 + "True": 80 test-flag1481: - percentage: 81 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 19 + "True": 81 test-flag1482: - percentage: 82 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 18 + "True": 82 test-flag1483: - percentage: 83 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 17 + "True": 83 test-flag1484: - percentage: 84 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 16 + "True": 84 test-flag1485: - percentage: 85 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 15 + "True": 85 test-flag1486: - percentage: 86 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 14 + "True": 86 test-flag1487: - percentage: 87 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 13 + "True": 87 test-flag1488: - percentage: 88 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 12 + "True": 88 test-flag1489: - percentage: 89 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 11 + "True": 89 test-flag1490: - percentage: 90 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 10 + "True": 90 test-flag1491: - percentage: 91 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 9 + "True": 91 test-flag1492: - percentage: 92 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 8 + "True": 92 test-flag1493: - percentage: 93 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 7 + "True": 93 test-flag1494: - percentage: 94 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 6 + "True": 94 test-flag1495: - percentage: 95 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 5 + "True": 95 test-flag1496: - percentage: 96 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 4 + "True": 96 test-flag1497: - percentage: 97 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 3 + "True": 97 test-flag1498: - percentage: 98 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 2 + "True": 98 test-flag1499: - percentage: 99 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 1 + "True": 99 test-flag1500: - percentage: 0 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 100 + "True": 0 test-flag1501: - percentage: 1 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 99 + "True": 1 test-flag1502: - percentage: 2 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 98 + "True": 2 test-flag1503: - percentage: 3 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 97 + "True": 3 test-flag1504: - percentage: 4 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 96 + "True": 4 test-flag1505: - percentage: 5 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 95 + "True": 5 test-flag1506: - percentage: 6 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 94 + "True": 6 test-flag1507: - percentage: 7 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 93 + "True": 7 test-flag1508: - percentage: 8 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 92 + "True": 8 test-flag1509: - percentage: 9 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 91 + "True": 9 test-flag1510: - percentage: 10 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 90 + "True": 10 test-flag1511: - percentage: 11 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 89 + "True": 11 test-flag1512: - percentage: 12 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 88 + "True": 12 test-flag1513: - percentage: 13 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 87 + "True": 13 test-flag1514: - percentage: 14 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 86 + "True": 14 test-flag1515: - percentage: 15 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 85 + "True": 15 test-flag1516: - percentage: 16 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 84 + "True": 16 test-flag1517: - percentage: 17 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 83 + "True": 17 test-flag1518: - percentage: 18 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 82 + "True": 18 test-flag1519: - percentage: 19 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 81 + "True": 19 test-flag1520: - percentage: 20 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 80 + "True": 20 test-flag1521: - percentage: 21 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 79 + "True": 21 test-flag1522: - percentage: 22 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 78 + "True": 22 test-flag1523: - percentage: 23 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 77 + "True": 23 test-flag1524: - percentage: 24 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 76 + "True": 24 test-flag1525: - percentage: 25 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 75 + "True": 25 test-flag1526: - percentage: 26 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 74 + "True": 26 test-flag1527: - percentage: 27 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 73 + "True": 27 test-flag1528: - percentage: 28 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 72 + "True": 28 test-flag1529: - percentage: 29 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 71 + "True": 29 test-flag1530: - percentage: 30 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 70 + "True": 30 test-flag1531: - percentage: 31 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 69 + "True": 31 test-flag1532: - percentage: 32 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 68 + "True": 32 test-flag1533: - percentage: 33 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 67 + "True": 33 test-flag1534: - percentage: 34 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 66 + "True": 34 test-flag1535: - percentage: 35 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 65 + "True": 35 test-flag1536: - percentage: 36 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 64 + "True": 36 test-flag1537: - percentage: 37 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 63 + "True": 37 test-flag1538: - percentage: 38 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 62 + "True": 38 test-flag1539: - percentage: 39 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 61 + "True": 39 test-flag1540: - percentage: 40 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 60 + "True": 40 test-flag1541: - percentage: 41 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 59 + "True": 41 test-flag1542: - percentage: 42 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 58 + "True": 42 test-flag1543: - percentage: 43 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 57 + "True": 43 test-flag1544: - percentage: 44 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 56 + "True": 44 test-flag1545: - percentage: 45 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 55 + "True": 45 test-flag1546: - percentage: 46 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 54 + "True": 46 test-flag1547: - percentage: 47 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 53 + "True": 47 test-flag1548: - percentage: 48 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 52 + "True": 48 test-flag1549: - percentage: 49 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 51 + "True": 49 test-flag1550: - percentage: 50 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 50 + "True": 50 test-flag1551: - percentage: 51 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 49 + "True": 51 test-flag1552: - percentage: 52 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 48 + "True": 52 test-flag1553: - percentage: 53 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 47 + "True": 53 test-flag1554: - percentage: 54 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 46 + "True": 54 test-flag1555: - percentage: 55 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 45 + "True": 55 test-flag1556: - percentage: 56 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 44 + "True": 56 test-flag1557: - percentage: 57 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 43 + "True": 57 test-flag1558: - percentage: 58 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 42 + "True": 58 test-flag1559: - percentage: 59 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 41 + "True": 59 test-flag1560: - percentage: 60 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 40 + "True": 60 test-flag1561: - percentage: 61 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 39 + "True": 61 test-flag1562: - percentage: 62 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 38 + "True": 62 test-flag1563: - percentage: 63 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 37 + "True": 63 test-flag1564: - percentage: 64 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 36 + "True": 64 test-flag1565: - percentage: 65 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 35 + "True": 65 test-flag1566: - percentage: 66 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 34 + "True": 66 test-flag1567: - percentage: 67 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 33 + "True": 67 test-flag1568: - percentage: 68 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 32 + "True": 68 test-flag1569: - percentage: 69 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 31 + "True": 69 test-flag1570: - percentage: 70 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 30 + "True": 70 test-flag1571: - percentage: 71 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 29 + "True": 71 test-flag1572: - percentage: 72 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 28 + "True": 72 test-flag1573: - percentage: 73 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 27 + "True": 73 test-flag1574: - percentage: 74 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 26 + "True": 74 test-flag1575: - percentage: 75 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 25 + "True": 75 test-flag1576: - percentage: 76 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 24 + "True": 76 test-flag1577: - percentage: 77 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 23 + "True": 77 test-flag1578: - percentage: 78 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 22 + "True": 78 test-flag1579: - percentage: 79 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 21 + "True": 79 test-flag1580: - percentage: 80 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 20 + "True": 80 test-flag1581: - percentage: 81 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 19 + "True": 81 test-flag1582: - percentage: 82 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 18 + "True": 82 test-flag1583: - percentage: 83 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 17 + "True": 83 test-flag1584: - percentage: 84 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 16 + "True": 84 test-flag1585: - percentage: 85 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 15 + "True": 85 test-flag1586: - percentage: 86 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 14 + "True": 86 test-flag1587: - percentage: 87 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 13 + "True": 87 test-flag1588: - percentage: 88 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 12 + "True": 88 test-flag1589: - percentage: 89 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 11 + "True": 89 test-flag1590: - percentage: 90 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 10 + "True": 90 test-flag1591: - percentage: 91 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 9 + "True": 91 test-flag1592: - percentage: 92 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 8 + "True": 92 test-flag1593: - percentage: 93 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 7 + "True": 93 test-flag1594: - percentage: 94 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 6 + "True": 94 test-flag1595: - percentage: 95 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 5 + "True": 95 test-flag1596: - percentage: 96 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 4 + "True": 96 test-flag1597: - percentage: 97 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 3 + "True": 97 test-flag1598: - percentage: 98 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 2 + "True": 98 test-flag1599: - percentage: 99 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 1 + "True": 99 test-flag1600: - percentage: 0 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 100 + "True": 0 test-flag1601: - percentage: 1 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 99 + "True": 1 test-flag1602: - percentage: 2 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 98 + "True": 2 test-flag1603: - percentage: 3 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 97 + "True": 3 test-flag1604: - percentage: 4 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 96 + "True": 4 test-flag1605: - percentage: 5 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 95 + "True": 5 test-flag1606: - percentage: 6 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 94 + "True": 6 test-flag1607: - percentage: 7 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 93 + "True": 7 test-flag1608: - percentage: 8 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 92 + "True": 8 test-flag1609: - percentage: 9 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 91 + "True": 9 test-flag1610: - percentage: 10 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 90 + "True": 10 test-flag1611: - percentage: 11 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 89 + "True": 11 test-flag1612: - percentage: 12 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 88 + "True": 12 test-flag1613: - percentage: 13 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 87 + "True": 13 test-flag1614: - percentage: 14 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 86 + "True": 14 test-flag1615: - percentage: 15 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 85 + "True": 15 test-flag1616: - percentage: 16 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 84 + "True": 16 test-flag1617: - percentage: 17 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 83 + "True": 17 test-flag1618: - percentage: 18 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 82 + "True": 18 test-flag1619: - percentage: 19 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 81 + "True": 19 test-flag1620: - percentage: 20 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 80 + "True": 20 test-flag1621: - percentage: 21 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 79 + "True": 21 test-flag1622: - percentage: 22 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 78 + "True": 22 test-flag1623: - percentage: 23 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 77 + "True": 23 test-flag1624: - percentage: 24 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 76 + "True": 24 test-flag1625: - percentage: 25 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 75 + "True": 25 test-flag1626: - percentage: 26 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 74 + "True": 26 test-flag1627: - percentage: 27 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 73 + "True": 27 test-flag1628: - percentage: 28 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 72 + "True": 28 test-flag1629: - percentage: 29 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 71 + "True": 29 test-flag1630: - percentage: 30 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 70 + "True": 30 test-flag1631: - percentage: 31 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 69 + "True": 31 test-flag1632: - percentage: 32 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 68 + "True": 32 test-flag1633: - percentage: 33 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 67 + "True": 33 test-flag1634: - percentage: 34 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 66 + "True": 34 test-flag1635: - percentage: 35 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 65 + "True": 35 test-flag1636: - percentage: 36 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 64 + "True": 36 test-flag1637: - percentage: 37 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 63 + "True": 37 test-flag1638: - percentage: 38 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 62 + "True": 38 test-flag1639: - percentage: 39 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 61 + "True": 39 test-flag1640: - percentage: 40 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 60 + "True": 40 test-flag1641: - percentage: 41 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 59 + "True": 41 test-flag1642: - percentage: 42 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 58 + "True": 42 test-flag1643: - percentage: 43 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 57 + "True": 43 test-flag1644: - percentage: 44 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 56 + "True": 44 test-flag1645: - percentage: 45 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 55 + "True": 45 test-flag1646: - percentage: 46 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 54 + "True": 46 test-flag1647: - percentage: 47 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 53 + "True": 47 test-flag1648: - percentage: 48 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 52 + "True": 48 test-flag1649: - percentage: 49 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 51 + "True": 49 test-flag1650: - percentage: 50 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 50 + "True": 50 test-flag1651: - percentage: 51 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 49 + "True": 51 test-flag1652: - percentage: 52 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 48 + "True": 52 test-flag1653: - percentage: 53 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 47 + "True": 53 test-flag1654: - percentage: 54 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 46 + "True": 54 test-flag1655: - percentage: 55 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 45 + "True": 55 test-flag1656: - percentage: 56 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 44 + "True": 56 test-flag1657: - percentage: 57 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 43 + "True": 57 test-flag1658: - percentage: 58 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 42 + "True": 58 test-flag1659: - percentage: 59 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 41 + "True": 59 test-flag1660: - percentage: 60 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 40 + "True": 60 test-flag1661: - percentage: 61 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 39 + "True": 61 test-flag1662: - percentage: 62 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 38 + "True": 62 test-flag1663: - percentage: 63 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 37 + "True": 63 test-flag1664: - percentage: 64 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 36 + "True": 64 test-flag1665: - percentage: 65 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 35 + "True": 65 test-flag1666: - percentage: 66 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 34 + "True": 66 test-flag1667: - percentage: 67 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 33 + "True": 67 test-flag1668: - percentage: 68 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 32 + "True": 68 test-flag1669: - percentage: 69 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 31 + "True": 69 test-flag1670: - percentage: 70 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 30 + "True": 70 test-flag1671: - percentage: 71 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 29 + "True": 71 test-flag1672: - percentage: 72 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 28 + "True": 72 test-flag1673: - percentage: 73 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 27 + "True": 73 test-flag1674: - percentage: 74 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 26 + "True": 74 test-flag1675: - percentage: 75 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 25 + "True": 75 test-flag1676: - percentage: 76 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 24 + "True": 76 test-flag1677: - percentage: 77 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 23 + "True": 77 test-flag1678: - percentage: 78 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 22 + "True": 78 test-flag1679: - percentage: 79 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 21 + "True": 79 test-flag1680: - percentage: 80 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 20 + "True": 80 test-flag1681: - percentage: 81 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 19 + "True": 81 test-flag1682: - percentage: 82 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 18 + "True": 82 test-flag1683: - percentage: 83 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 17 + "True": 83 test-flag1684: - percentage: 84 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 16 + "True": 84 test-flag1685: - percentage: 85 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 15 + "True": 85 test-flag1686: - percentage: 86 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 14 + "True": 86 test-flag1687: - percentage: 87 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 13 + "True": 87 test-flag1688: - percentage: 88 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 12 + "True": 88 test-flag1689: - percentage: 89 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 11 + "True": 89 test-flag1690: - percentage: 90 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 10 + "True": 90 test-flag1691: - percentage: 91 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 9 + "True": 91 test-flag1692: - percentage: 92 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 8 + "True": 92 test-flag1693: - percentage: 93 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 7 + "True": 93 test-flag1694: - percentage: 94 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 6 + "True": 94 test-flag1695: - percentage: 95 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 5 + "True": 95 test-flag1696: - percentage: 96 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 4 + "True": 96 test-flag1697: - percentage: 97 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 3 + "True": 97 test-flag1698: - percentage: 98 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 2 + "True": 98 test-flag1699: - percentage: 99 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 1 + "True": 99 test-flag1700: - percentage: 0 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 100 + "True": 0 test-flag1701: - percentage: 1 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 99 + "True": 1 test-flag1702: - percentage: 2 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 98 + "True": 2 test-flag1703: - percentage: 3 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 97 + "True": 3 test-flag1704: - percentage: 4 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 96 + "True": 4 test-flag1705: - percentage: 5 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 95 + "True": 5 test-flag1706: - percentage: 6 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 94 + "True": 6 test-flag1707: - percentage: 7 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 93 + "True": 7 test-flag1708: - percentage: 8 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 92 + "True": 8 test-flag1709: - percentage: 9 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 91 + "True": 9 test-flag1710: - percentage: 10 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 90 + "True": 10 test-flag1711: - percentage: 11 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 89 + "True": 11 test-flag1712: - percentage: 12 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 88 + "True": 12 test-flag1713: - percentage: 13 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 87 + "True": 13 test-flag1714: - percentage: 14 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 86 + "True": 14 test-flag1715: - percentage: 15 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 85 + "True": 15 test-flag1716: - percentage: 16 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 84 + "True": 16 test-flag1717: - percentage: 17 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 83 + "True": 17 test-flag1718: - percentage: 18 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 82 + "True": 18 test-flag1719: - percentage: 19 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 81 + "True": 19 test-flag1720: - percentage: 20 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 80 + "True": 20 test-flag1721: - percentage: 21 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 79 + "True": 21 test-flag1722: - percentage: 22 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 78 + "True": 22 test-flag1723: - percentage: 23 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 77 + "True": 23 test-flag1724: - percentage: 24 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 76 + "True": 24 test-flag1725: - percentage: 25 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 75 + "True": 25 test-flag1726: - percentage: 26 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 74 + "True": 26 test-flag1727: - percentage: 27 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 73 + "True": 27 test-flag1728: - percentage: 28 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 72 + "True": 28 test-flag1729: - percentage: 29 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 71 + "True": 29 test-flag1730: - percentage: 30 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 70 + "True": 30 test-flag1731: - percentage: 31 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 69 + "True": 31 test-flag1732: - percentage: 32 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 68 + "True": 32 test-flag1733: - percentage: 33 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 67 + "True": 33 test-flag1734: - percentage: 34 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 66 + "True": 34 test-flag1735: - percentage: 35 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 65 + "True": 35 test-flag1736: - percentage: 36 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 64 + "True": 36 test-flag1737: - percentage: 37 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 63 + "True": 37 test-flag1738: - percentage: 38 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 62 + "True": 38 test-flag1739: - percentage: 39 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 61 + "True": 39 test-flag1740: - percentage: 40 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 60 + "True": 40 test-flag1741: - percentage: 41 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 59 + "True": 41 test-flag1742: - percentage: 42 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 58 + "True": 42 test-flag1743: - percentage: 43 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 57 + "True": 43 test-flag1744: - percentage: 44 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 56 + "True": 44 test-flag1745: - percentage: 45 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 55 + "True": 45 test-flag1746: - percentage: 46 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 54 + "True": 46 test-flag1747: - percentage: 47 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 53 + "True": 47 test-flag1748: - percentage: 48 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 52 + "True": 48 test-flag1749: - percentage: 49 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 51 + "True": 49 test-flag1750: - percentage: 50 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 50 + "True": 50 test-flag1751: - percentage: 51 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 49 + "True": 51 test-flag1752: - percentage: 52 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 48 + "True": 52 test-flag1753: - percentage: 53 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 47 + "True": 53 test-flag1754: - percentage: 54 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 46 + "True": 54 test-flag1755: - percentage: 55 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 45 + "True": 55 test-flag1756: - percentage: 56 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 44 + "True": 56 test-flag1757: - percentage: 57 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 43 + "True": 57 test-flag1758: - percentage: 58 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 42 + "True": 58 test-flag1759: - percentage: 59 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 41 + "True": 59 test-flag1760: - percentage: 60 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 40 + "True": 60 test-flag1761: - percentage: 61 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 39 + "True": 61 test-flag1762: - percentage: 62 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 38 + "True": 62 test-flag1763: - percentage: 63 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 37 + "True": 63 test-flag1764: - percentage: 64 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 36 + "True": 64 test-flag1765: - percentage: 65 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 35 + "True": 65 test-flag1766: - percentage: 66 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 34 + "True": 66 test-flag1767: - percentage: 67 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 33 + "True": 67 test-flag1768: - percentage: 68 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 32 + "True": 68 test-flag1769: - percentage: 69 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 31 + "True": 69 test-flag1770: - percentage: 70 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 30 + "True": 70 test-flag1771: - percentage: 71 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 29 + "True": 71 test-flag1772: - percentage: 72 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 28 + "True": 72 test-flag1773: - percentage: 73 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 27 + "True": 73 test-flag1774: - percentage: 74 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 26 + "True": 74 test-flag1775: - percentage: 75 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 25 + "True": 75 test-flag1776: - percentage: 76 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 24 + "True": 76 test-flag1777: - percentage: 77 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 23 + "True": 77 test-flag1778: - percentage: 78 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 22 + "True": 78 test-flag1779: - percentage: 79 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 21 + "True": 79 test-flag1780: - percentage: 80 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 20 + "True": 80 test-flag1781: - percentage: 81 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 19 + "True": 81 test-flag1782: - percentage: 82 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 18 + "True": 82 test-flag1783: - percentage: 83 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 17 + "True": 83 test-flag1784: - percentage: 84 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 16 + "True": 84 test-flag1785: - percentage: 85 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 15 + "True": 85 test-flag1786: - percentage: 86 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 14 + "True": 86 test-flag1787: - percentage: 87 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 13 + "True": 87 test-flag1788: - percentage: 88 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 12 + "True": 88 test-flag1789: - percentage: 89 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 11 + "True": 89 test-flag1790: - percentage: 90 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 10 + "True": 90 test-flag1791: - percentage: 91 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 9 + "True": 91 test-flag1792: - percentage: 92 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 8 + "True": 92 test-flag1793: - percentage: 93 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 7 + "True": 93 test-flag1794: - percentage: 94 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 6 + "True": 94 test-flag1795: - percentage: 95 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 5 + "True": 95 test-flag1796: - percentage: 96 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 4 + "True": 96 test-flag1797: - percentage: 97 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 3 + "True": 97 test-flag1798: - percentage: 98 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 2 + "True": 98 test-flag1799: - percentage: 99 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 1 + "True": 99 test-flag1800: - percentage: 0 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 100 + "True": 0 test-flag1801: - percentage: 1 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 99 + "True": 1 test-flag1802: - percentage: 2 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 98 + "True": 2 test-flag1803: - percentage: 3 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 97 + "True": 3 test-flag1804: - percentage: 4 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 96 + "True": 4 test-flag1805: - percentage: 5 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 95 + "True": 5 test-flag1806: - percentage: 6 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 94 + "True": 6 test-flag1807: - percentage: 7 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 93 + "True": 7 test-flag1808: - percentage: 8 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 92 + "True": 8 test-flag1809: - percentage: 9 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 91 + "True": 9 test-flag1810: - percentage: 10 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 90 + "True": 10 test-flag1811: - percentage: 11 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 89 + "True": 11 test-flag1812: - percentage: 12 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 88 + "True": 12 test-flag1813: - percentage: 13 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 87 + "True": 13 test-flag1814: - percentage: 14 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 86 + "True": 14 test-flag1815: - percentage: 15 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 85 + "True": 15 test-flag1816: - percentage: 16 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 84 + "True": 16 test-flag1817: - percentage: 17 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 83 + "True": 17 test-flag1818: - percentage: 18 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 82 + "True": 18 test-flag1819: - percentage: 19 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 81 + "True": 19 test-flag1820: - percentage: 20 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 80 + "True": 20 test-flag1821: - percentage: 21 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 79 + "True": 21 test-flag1822: - percentage: 22 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 78 + "True": 22 test-flag1823: - percentage: 23 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 77 + "True": 23 test-flag1824: - percentage: 24 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 76 + "True": 24 test-flag1825: - percentage: 25 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 75 + "True": 25 test-flag1826: - percentage: 26 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 74 + "True": 26 test-flag1827: - percentage: 27 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 73 + "True": 27 test-flag1828: - percentage: 28 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 72 + "True": 28 test-flag1829: - percentage: 29 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 71 + "True": 29 test-flag1830: - percentage: 30 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 70 + "True": 30 test-flag1831: - percentage: 31 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 69 + "True": 31 test-flag1832: - percentage: 32 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 68 + "True": 32 test-flag1833: - percentage: 33 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 67 + "True": 33 test-flag1834: - percentage: 34 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 66 + "True": 34 test-flag1835: - percentage: 35 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 65 + "True": 35 test-flag1836: - percentage: 36 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 64 + "True": 36 test-flag1837: - percentage: 37 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 63 + "True": 37 test-flag1838: - percentage: 38 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 62 + "True": 38 test-flag1839: - percentage: 39 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 61 + "True": 39 test-flag1840: - percentage: 40 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 60 + "True": 40 test-flag1841: - percentage: 41 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 59 + "True": 41 test-flag1842: - percentage: 42 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 58 + "True": 42 test-flag1843: - percentage: 43 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 57 + "True": 43 test-flag1844: - percentage: 44 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 56 + "True": 44 test-flag1845: - percentage: 45 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 55 + "True": 45 test-flag1846: - percentage: 46 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 54 + "True": 46 test-flag1847: - percentage: 47 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 53 + "True": 47 test-flag1848: - percentage: 48 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 52 + "True": 48 test-flag1849: - percentage: 49 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 51 + "True": 49 test-flag1850: - percentage: 50 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 50 + "True": 50 test-flag1851: - percentage: 51 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 49 + "True": 51 test-flag1852: - percentage: 52 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 48 + "True": 52 test-flag1853: - percentage: 53 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 47 + "True": 53 test-flag1854: - percentage: 54 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 46 + "True": 54 test-flag1855: - percentage: 55 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 45 + "True": 55 test-flag1856: - percentage: 56 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 44 + "True": 56 test-flag1857: - percentage: 57 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 43 + "True": 57 test-flag1858: - percentage: 58 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 42 + "True": 58 test-flag1859: - percentage: 59 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 41 + "True": 59 test-flag1860: - percentage: 60 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 40 + "True": 60 test-flag1861: - percentage: 61 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 39 + "True": 61 test-flag1862: - percentage: 62 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 38 + "True": 62 test-flag1863: - percentage: 63 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 37 + "True": 63 test-flag1864: - percentage: 64 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 36 + "True": 64 test-flag1865: - percentage: 65 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 35 + "True": 65 test-flag1866: - percentage: 66 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 34 + "True": 66 test-flag1867: - percentage: 67 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 33 + "True": 67 test-flag1868: - percentage: 68 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 32 + "True": 68 test-flag1869: - percentage: 69 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 31 + "True": 69 test-flag1870: - percentage: 70 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 30 + "True": 70 test-flag1871: - percentage: 71 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 29 + "True": 71 test-flag1872: - percentage: 72 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 28 + "True": 72 test-flag1873: - percentage: 73 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 27 + "True": 73 test-flag1874: - percentage: 74 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 26 + "True": 74 test-flag1875: - percentage: 75 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 25 + "True": 75 test-flag1876: - percentage: 76 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 24 + "True": 76 test-flag1877: - percentage: 77 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 23 + "True": 77 test-flag1878: - percentage: 78 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 22 + "True": 78 test-flag1879: - percentage: 79 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 21 + "True": 79 test-flag1880: - percentage: 80 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 20 + "True": 80 test-flag1881: - percentage: 81 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 19 + "True": 81 test-flag1882: - percentage: 82 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 18 + "True": 82 test-flag1883: - percentage: 83 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 17 + "True": 83 test-flag1884: - percentage: 84 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 16 + "True": 84 test-flag1885: - percentage: 85 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 15 + "True": 85 test-flag1886: - percentage: 86 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 14 + "True": 86 test-flag1887: - percentage: 87 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 13 + "True": 87 test-flag1888: - percentage: 88 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 12 + "True": 88 test-flag1889: - percentage: 89 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 11 + "True": 89 test-flag1890: - percentage: 90 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 10 + "True": 90 test-flag1891: - percentage: 91 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 9 + "True": 91 test-flag1892: - percentage: 92 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 8 + "True": 92 test-flag1893: - percentage: 93 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 7 + "True": 93 test-flag1894: - percentage: 94 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 6 + "True": 94 test-flag1895: - percentage: 95 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 5 + "True": 95 test-flag1896: - percentage: 96 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 4 + "True": 96 test-flag1897: - percentage: 97 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 3 + "True": 97 test-flag1898: - percentage: 98 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 2 + "True": 98 test-flag1899: - percentage: 99 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 1 + "True": 99 test-flag1900: - percentage: 0 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 100 + "True": 0 test-flag1901: - percentage: 1 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 99 + "True": 1 test-flag1902: - percentage: 2 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 98 + "True": 2 test-flag1903: - percentage: 3 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 97 + "True": 3 test-flag1904: - percentage: 4 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 96 + "True": 4 test-flag1905: - percentage: 5 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 95 + "True": 5 test-flag1906: - percentage: 6 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 94 + "True": 6 test-flag1907: - percentage: 7 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 93 + "True": 7 test-flag1908: - percentage: 8 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 92 + "True": 8 test-flag1909: - percentage: 9 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 91 + "True": 9 test-flag1910: - percentage: 10 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 90 + "True": 10 test-flag1911: - percentage: 11 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 89 + "True": 11 test-flag1912: - percentage: 12 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 88 + "True": 12 test-flag1913: - percentage: 13 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 87 + "True": 13 test-flag1914: - percentage: 14 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 86 + "True": 14 test-flag1915: - percentage: 15 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 85 + "True": 15 test-flag1916: - percentage: 16 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 84 + "True": 16 test-flag1917: - percentage: 17 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 83 + "True": 17 test-flag1918: - percentage: 18 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 82 + "True": 18 test-flag1919: - percentage: 19 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 81 + "True": 19 test-flag1920: - percentage: 20 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 80 + "True": 20 test-flag1921: - percentage: 21 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 79 + "True": 21 test-flag1922: - percentage: 22 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 78 + "True": 22 test-flag1923: - percentage: 23 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 77 + "True": 23 test-flag1924: - percentage: 24 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 76 + "True": 24 test-flag1925: - percentage: 25 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 75 + "True": 25 test-flag1926: - percentage: 26 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 74 + "True": 26 test-flag1927: - percentage: 27 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 73 + "True": 27 test-flag1928: - percentage: 28 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 72 + "True": 28 test-flag1929: - percentage: 29 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 71 + "True": 29 test-flag1930: - percentage: 30 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 70 + "True": 30 test-flag1931: - percentage: 31 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 69 + "True": 31 test-flag1932: - percentage: 32 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 68 + "True": 32 test-flag1933: - percentage: 33 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 67 + "True": 33 test-flag1934: - percentage: 34 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 66 + "True": 34 test-flag1935: - percentage: 35 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 65 + "True": 35 test-flag1936: - percentage: 36 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 64 + "True": 36 test-flag1937: - percentage: 37 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 63 + "True": 37 test-flag1938: - percentage: 38 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 62 + "True": 38 test-flag1939: - percentage: 39 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 61 + "True": 39 test-flag1940: - percentage: 40 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 60 + "True": 40 test-flag1941: - percentage: 41 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 59 + "True": 41 test-flag1942: - percentage: 42 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 58 + "True": 42 test-flag1943: - percentage: 43 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 57 + "True": 43 test-flag1944: - percentage: 44 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 56 + "True": 44 test-flag1945: - percentage: 45 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 55 + "True": 45 test-flag1946: - percentage: 46 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 54 + "True": 46 test-flag1947: - percentage: 47 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 53 + "True": 47 test-flag1948: - percentage: 48 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 52 + "True": 48 test-flag1949: - percentage: 49 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 51 + "True": 49 test-flag1950: - percentage: 50 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 50 + "True": 50 test-flag1951: - percentage: 51 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 49 + "True": 51 test-flag1952: - percentage: 52 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 48 + "True": 52 test-flag1953: - percentage: 53 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 47 + "True": 53 test-flag1954: - percentage: 54 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 46 + "True": 54 test-flag1955: - percentage: 55 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 45 + "True": 55 test-flag1956: - percentage: 56 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 44 + "True": 56 test-flag1957: - percentage: 57 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 43 + "True": 57 test-flag1958: - percentage: 58 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 42 + "True": 58 test-flag1959: - percentage: 59 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 41 + "True": 59 test-flag1960: - percentage: 60 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 40 + "True": 60 test-flag1961: - percentage: 61 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 39 + "True": 61 test-flag1962: - percentage: 62 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 38 + "True": 62 test-flag1963: - percentage: 63 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 37 + "True": 63 test-flag1964: - percentage: 64 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 36 + "True": 64 test-flag1965: - percentage: 65 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 35 + "True": 65 test-flag1966: - percentage: 66 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 34 + "True": 66 test-flag1967: - percentage: 67 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 33 + "True": 67 test-flag1968: - percentage: 68 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 32 + "True": 68 test-flag1969: - percentage: 69 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 31 + "True": 69 test-flag1970: - percentage: 70 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 30 + "True": 70 test-flag1971: - percentage: 71 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 29 + "True": 71 test-flag1972: - percentage: 72 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 28 + "True": 72 test-flag1973: - percentage: 73 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 27 + "True": 73 test-flag1974: - percentage: 74 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 26 + "True": 74 test-flag1975: - percentage: 75 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 25 + "True": 75 test-flag1976: - percentage: 76 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 24 + "True": 76 test-flag1977: - percentage: 77 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 23 + "True": 77 test-flag1978: - percentage: 78 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 22 + "True": 78 test-flag1979: - percentage: 79 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 21 + "True": 79 test-flag1980: - percentage: 80 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 20 + "True": 80 test-flag1981: - percentage: 81 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 19 + "True": 81 test-flag1982: - percentage: 82 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 18 + "True": 82 test-flag1983: - percentage: 83 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 17 + "True": 83 test-flag1984: - percentage: 84 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 16 + "True": 84 test-flag1985: - percentage: 85 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 15 + "True": 85 test-flag1986: - percentage: 86 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 14 + "True": 86 test-flag1987: - percentage: 87 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 13 + "True": 87 test-flag1988: - percentage: 88 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 12 + "True": 88 test-flag1989: - percentage: 89 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 11 + "True": 89 test-flag1990: - percentage: 90 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 10 + "True": 90 test-flag1991: - percentage: 91 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 9 + "True": 91 test-flag1992: - percentage: 92 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 8 + "True": 92 test-flag1993: - percentage: 93 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 7 + "True": 93 test-flag1994: - percentage: 94 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 6 + "True": 94 test-flag1995: - percentage: 95 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 5 + "True": 95 test-flag1996: - percentage: 96 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 4 + "True": 96 test-flag1997: - percentage: 97 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 3 + "True": 97 test-flag1998: - percentage: 98 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 2 + "True": 98 test-flag1999: - percentage: 99 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 1 + "True": 99 test-flag2000: - percentage: 0 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 100 + "True": 0 test-flag2001: - percentage: 1 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 99 + "True": 1 test-flag2002: - percentage: 2 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 98 + "True": 2 test-flag2003: - percentage: 3 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 97 + "True": 3 test-flag2004: - percentage: 4 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 96 + "True": 4 test-flag2005: - percentage: 5 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 95 + "True": 5 test-flag2006: - percentage: 6 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 94 + "True": 6 test-flag2007: - percentage: 7 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 93 + "True": 7 test-flag2008: - percentage: 8 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 92 + "True": 8 test-flag2009: - percentage: 9 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 91 + "True": 9 test-flag2010: - percentage: 10 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 90 + "True": 10 test-flag2011: - percentage: 11 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 89 + "True": 11 test-flag2012: - percentage: 12 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 88 + "True": 12 test-flag2013: - percentage: 13 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 87 + "True": 13 test-flag2014: - percentage: 14 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 86 + "True": 14 test-flag2015: - percentage: 15 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 85 + "True": 15 test-flag2016: - percentage: 16 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 84 + "True": 16 test-flag2017: - percentage: 17 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 83 + "True": 17 test-flag2018: - percentage: 18 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 82 + "True": 18 test-flag2019: - percentage: 19 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 81 + "True": 19 test-flag2020: - percentage: 20 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 80 + "True": 20 test-flag2021: - percentage: 21 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 79 + "True": 21 test-flag2022: - percentage: 22 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 78 + "True": 22 test-flag2023: - percentage: 23 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 77 + "True": 23 test-flag2024: - percentage: 24 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 76 + "True": 24 test-flag2025: - percentage: 25 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 75 + "True": 25 test-flag2026: - percentage: 26 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 74 + "True": 26 test-flag2027: - percentage: 27 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 73 + "True": 27 test-flag2028: - percentage: 28 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 72 + "True": 28 test-flag2029: - percentage: 29 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 71 + "True": 29 test-flag2030: - percentage: 30 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 70 + "True": 30 test-flag2031: - percentage: 31 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 69 + "True": 31 test-flag2032: - percentage: 32 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 68 + "True": 32 test-flag2033: - percentage: 33 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 67 + "True": 33 test-flag2034: - percentage: 34 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 66 + "True": 34 test-flag2035: - percentage: 35 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 65 + "True": 35 test-flag2036: - percentage: 36 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 64 + "True": 36 test-flag2037: - percentage: 37 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 63 + "True": 37 test-flag2038: - percentage: 38 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 62 + "True": 38 test-flag2039: - percentage: 39 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 61 + "True": 39 test-flag2040: - percentage: 40 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 60 + "True": 40 test-flag2041: - percentage: 41 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 59 + "True": 41 test-flag2042: - percentage: 42 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 58 + "True": 42 test-flag2043: - percentage: 43 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 57 + "True": 43 test-flag2044: - percentage: 44 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 56 + "True": 44 test-flag2045: - percentage: 45 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 55 + "True": 45 test-flag2046: - percentage: 46 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 54 + "True": 46 test-flag2047: - percentage: 47 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 53 + "True": 47 test-flag2048: - percentage: 48 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 52 + "True": 48 test-flag2049: - percentage: 49 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 51 + "True": 49 test-flag2050: - percentage: 50 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 50 + "True": 50 test-flag2051: - percentage: 51 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 49 + "True": 51 test-flag2052: - percentage: 52 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 48 + "True": 52 test-flag2053: - percentage: 53 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 47 + "True": 53 test-flag2054: - percentage: 54 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 46 + "True": 54 test-flag2055: - percentage: 55 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 45 + "True": 55 test-flag2056: - percentage: 56 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 44 + "True": 56 test-flag2057: - percentage: 57 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 43 + "True": 57 test-flag2058: - percentage: 58 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 42 + "True": 58 test-flag2059: - percentage: 59 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 41 + "True": 59 test-flag2060: - percentage: 60 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 40 + "True": 60 test-flag2061: - percentage: 61 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 39 + "True": 61 test-flag2062: - percentage: 62 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 38 + "True": 62 test-flag2063: - percentage: 63 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 37 + "True": 63 test-flag2064: - percentage: 64 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 36 + "True": 64 test-flag2065: - percentage: 65 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 35 + "True": 65 test-flag2066: - percentage: 66 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 34 + "True": 66 test-flag2067: - percentage: 67 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 33 + "True": 67 test-flag2068: - percentage: 68 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 32 + "True": 68 test-flag2069: - percentage: 69 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 31 + "True": 69 test-flag2070: - percentage: 70 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 30 + "True": 70 test-flag2071: - percentage: 71 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 29 + "True": 71 test-flag2072: - percentage: 72 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 28 + "True": 72 test-flag2073: - percentage: 73 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 27 + "True": 73 test-flag2074: - percentage: 74 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 26 + "True": 74 test-flag2075: - percentage: 75 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 25 + "True": 75 test-flag2076: - percentage: 76 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 24 + "True": 76 test-flag2077: - percentage: 77 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 23 + "True": 77 test-flag2078: - percentage: 78 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 22 + "True": 78 test-flag2079: - percentage: 79 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 21 + "True": 79 test-flag2080: - percentage: 80 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 20 + "True": 80 test-flag2081: - percentage: 81 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 19 + "True": 81 test-flag2082: - percentage: 82 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 18 + "True": 82 test-flag2083: - percentage: 83 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 17 + "True": 83 test-flag2084: - percentage: 84 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 16 + "True": 84 test-flag2085: - percentage: 85 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 15 + "True": 85 test-flag2086: - percentage: 86 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 14 + "True": 86 test-flag2087: - percentage: 87 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 13 + "True": 87 test-flag2088: - percentage: 88 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 12 + "True": 88 test-flag2089: - percentage: 89 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 11 + "True": 89 test-flag2090: - percentage: 90 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 10 + "True": 90 test-flag2091: - percentage: 91 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 9 + "True": 91 test-flag2092: - percentage: 92 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 8 + "True": 92 test-flag2093: - percentage: 93 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 7 + "True": 93 test-flag2094: - percentage: 94 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 6 + "True": 94 test-flag2095: - percentage: 95 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 5 + "True": 95 test-flag2096: - percentage: 96 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 4 + "True": 96 test-flag2097: - percentage: 97 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 3 + "True": 97 test-flag2098: - percentage: 98 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 2 + "True": 98 test-flag2099: - percentage: 99 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 1 + "True": 99 test-flag2100: - percentage: 0 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 100 + "True": 0 test-flag2101: - percentage: 1 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 99 + "True": 1 test-flag2102: - percentage: 2 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 98 + "True": 2 test-flag2103: - percentage: 3 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 97 + "True": 3 test-flag2104: - percentage: 4 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 96 + "True": 4 test-flag2105: - percentage: 5 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 95 + "True": 5 test-flag2106: - percentage: 6 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 94 + "True": 6 test-flag2107: - percentage: 7 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 93 + "True": 7 test-flag2108: - percentage: 8 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 92 + "True": 8 test-flag2109: - percentage: 9 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 91 + "True": 9 test-flag2110: - percentage: 10 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 90 + "True": 10 test-flag2111: - percentage: 11 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 89 + "True": 11 test-flag2112: - percentage: 12 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 88 + "True": 12 test-flag2113: - percentage: 13 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 87 + "True": 13 test-flag2114: - percentage: 14 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 86 + "True": 14 test-flag2115: - percentage: 15 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 85 + "True": 15 test-flag2116: - percentage: 16 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 84 + "True": 16 test-flag2117: - percentage: 17 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 83 + "True": 17 test-flag2118: - percentage: 18 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 82 + "True": 18 test-flag2119: - percentage: 19 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 81 + "True": 19 test-flag2120: - percentage: 20 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 80 + "True": 20 test-flag2121: - percentage: 21 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 79 + "True": 21 test-flag2122: - percentage: 22 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 78 + "True": 22 test-flag2123: - percentage: 23 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 77 + "True": 23 test-flag2124: - percentage: 24 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 76 + "True": 24 test-flag2125: - percentage: 25 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 75 + "True": 25 test-flag2126: - percentage: 26 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 74 + "True": 26 test-flag2127: - percentage: 27 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 73 + "True": 27 test-flag2128: - percentage: 28 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 72 + "True": 28 test-flag2129: - percentage: 29 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 71 + "True": 29 test-flag2130: - percentage: 30 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 70 + "True": 30 test-flag2131: - percentage: 31 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 69 + "True": 31 test-flag2132: - percentage: 32 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 68 + "True": 32 test-flag2133: - percentage: 33 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 67 + "True": 33 test-flag2134: - percentage: 34 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 66 + "True": 34 test-flag2135: - percentage: 35 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 65 + "True": 35 test-flag2136: - percentage: 36 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 64 + "True": 36 test-flag2137: - percentage: 37 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 63 + "True": 37 test-flag2138: - percentage: 38 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 62 + "True": 38 test-flag2139: - percentage: 39 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 61 + "True": 39 test-flag2140: - percentage: 40 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 60 + "True": 40 test-flag2141: - percentage: 41 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 59 + "True": 41 test-flag2142: - percentage: 42 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 58 + "True": 42 test-flag2143: - percentage: 43 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 57 + "True": 43 test-flag2144: - percentage: 44 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 56 + "True": 44 test-flag2145: - percentage: 45 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 55 + "True": 45 test-flag2146: - percentage: 46 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 54 + "True": 46 test-flag2147: - percentage: 47 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 53 + "True": 47 test-flag2148: - percentage: 48 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 52 + "True": 48 test-flag2149: - percentage: 49 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 51 + "True": 49 test-flag2150: - percentage: 50 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 50 + "True": 50 test-flag2151: - percentage: 51 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 49 + "True": 51 test-flag2152: - percentage: 52 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 48 + "True": 52 test-flag2153: - percentage: 53 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 47 + "True": 53 test-flag2154: - percentage: 54 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 46 + "True": 54 test-flag2155: - percentage: 55 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 45 + "True": 55 test-flag2156: - percentage: 56 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 44 + "True": 56 test-flag2157: - percentage: 57 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 43 + "True": 57 test-flag2158: - percentage: 58 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 42 + "True": 58 test-flag2159: - percentage: 59 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 41 + "True": 59 test-flag2160: - percentage: 60 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 40 + "True": 60 test-flag2161: - percentage: 61 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 39 + "True": 61 test-flag2162: - percentage: 62 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 38 + "True": 62 test-flag2163: - percentage: 63 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 37 + "True": 63 test-flag2164: - percentage: 64 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 36 + "True": 64 test-flag2165: - percentage: 65 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 35 + "True": 65 test-flag2166: - percentage: 66 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 34 + "True": 66 test-flag2167: - percentage: 67 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 33 + "True": 67 test-flag2168: - percentage: 68 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 32 + "True": 68 test-flag2169: - percentage: 69 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 31 + "True": 69 test-flag2170: - percentage: 70 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 30 + "True": 70 test-flag2171: - percentage: 71 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 29 + "True": 71 test-flag2172: - percentage: 72 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 28 + "True": 72 test-flag2173: - percentage: 73 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 27 + "True": 73 test-flag2174: - percentage: 74 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 26 + "True": 74 test-flag2175: - percentage: 75 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 25 + "True": 75 test-flag2176: - percentage: 76 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 24 + "True": 76 test-flag2177: - percentage: 77 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 23 + "True": 77 test-flag2178: - percentage: 78 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 22 + "True": 78 test-flag2179: - percentage: 79 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 21 + "True": 79 test-flag2180: - percentage: 80 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 20 + "True": 80 test-flag2181: - percentage: 81 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 19 + "True": 81 test-flag2182: - percentage: 82 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 18 + "True": 82 test-flag2183: - percentage: 83 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 17 + "True": 83 test-flag2184: - percentage: 84 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 16 + "True": 84 test-flag2185: - percentage: 85 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 15 + "True": 85 test-flag2186: - percentage: 86 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 14 + "True": 86 test-flag2187: - percentage: 87 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 13 + "True": 87 test-flag2188: - percentage: 88 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 12 + "True": 88 test-flag2189: - percentage: 89 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 11 + "True": 89 test-flag2190: - percentage: 90 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 10 + "True": 90 test-flag2191: - percentage: 91 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 9 + "True": 91 test-flag2192: - percentage: 92 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 8 + "True": 92 test-flag2193: - percentage: 93 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 7 + "True": 93 test-flag2194: - percentage: 94 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 6 + "True": 94 test-flag2195: - percentage: 95 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 5 + "True": 95 test-flag2196: - percentage: 96 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 4 + "True": 96 test-flag2197: - percentage: 97 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 3 + "True": 97 test-flag2198: - percentage: 98 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 2 + "True": 98 test-flag2199: - percentage: 99 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 1 + "True": 99 test-flag2200: - percentage: 0 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 100 + "True": 0 test-flag2201: - percentage: 1 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 99 + "True": 1 test-flag2202: - percentage: 2 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 98 + "True": 2 test-flag2203: - percentage: 3 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 97 + "True": 3 test-flag2204: - percentage: 4 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 96 + "True": 4 test-flag2205: - percentage: 5 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 95 + "True": 5 test-flag2206: - percentage: 6 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 94 + "True": 6 test-flag2207: - percentage: 7 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 93 + "True": 7 test-flag2208: - percentage: 8 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 92 + "True": 8 test-flag2209: - percentage: 9 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 91 + "True": 9 test-flag2210: - percentage: 10 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 90 + "True": 10 test-flag2211: - percentage: 11 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 89 + "True": 11 test-flag2212: - percentage: 12 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 88 + "True": 12 test-flag2213: - percentage: 13 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 87 + "True": 13 test-flag2214: - percentage: 14 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 86 + "True": 14 test-flag2215: - percentage: 15 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 85 + "True": 15 test-flag2216: - percentage: 16 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 84 + "True": 16 test-flag2217: - percentage: 17 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 83 + "True": 17 test-flag2218: - percentage: 18 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 82 + "True": 18 test-flag2219: - percentage: 19 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 81 + "True": 19 test-flag2220: - percentage: 20 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 80 + "True": 20 test-flag2221: - percentage: 21 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 79 + "True": 21 test-flag2222: - percentage: 22 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 78 + "True": 22 test-flag2223: - percentage: 23 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 77 + "True": 23 test-flag2224: - percentage: 24 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 76 + "True": 24 test-flag2225: - percentage: 25 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 75 + "True": 25 test-flag2226: - percentage: 26 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 74 + "True": 26 test-flag2227: - percentage: 27 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 73 + "True": 27 test-flag2228: - percentage: 28 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 72 + "True": 28 test-flag2229: - percentage: 29 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 71 + "True": 29 test-flag2230: - percentage: 30 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 70 + "True": 30 test-flag2231: - percentage: 31 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 69 + "True": 31 test-flag2232: - percentage: 32 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 68 + "True": 32 test-flag2233: - percentage: 33 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 67 + "True": 33 test-flag2234: - percentage: 34 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 66 + "True": 34 test-flag2235: - percentage: 35 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 65 + "True": 35 test-flag2236: - percentage: 36 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 64 + "True": 36 test-flag2237: - percentage: 37 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 63 + "True": 37 test-flag2238: - percentage: 38 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 62 + "True": 38 test-flag2239: - percentage: 39 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 61 + "True": 39 test-flag2240: - percentage: 40 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 60 + "True": 40 test-flag2241: - percentage: 41 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 59 + "True": 41 test-flag2242: - percentage: 42 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 58 + "True": 42 test-flag2243: - percentage: 43 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 57 + "True": 43 test-flag2244: - percentage: 44 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 56 + "True": 44 test-flag2245: - percentage: 45 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 55 + "True": 45 test-flag2246: - percentage: 46 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 54 + "True": 46 test-flag2247: - percentage: 47 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 53 + "True": 47 test-flag2248: - percentage: 48 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 52 + "True": 48 test-flag2249: - percentage: 49 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 51 + "True": 49 test-flag2250: - percentage: 50 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 50 + "True": 50 test-flag2251: - percentage: 51 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 49 + "True": 51 test-flag2252: - percentage: 52 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 48 + "True": 52 test-flag2253: - percentage: 53 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 47 + "True": 53 test-flag2254: - percentage: 54 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 46 + "True": 54 test-flag2255: - percentage: 55 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 45 + "True": 55 test-flag2256: - percentage: 56 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 44 + "True": 56 test-flag2257: - percentage: 57 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 43 + "True": 57 test-flag2258: - percentage: 58 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 42 + "True": 58 test-flag2259: - percentage: 59 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 41 + "True": 59 test-flag2260: - percentage: 60 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 40 + "True": 60 test-flag2261: - percentage: 61 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 39 + "True": 61 test-flag2262: - percentage: 62 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 38 + "True": 62 test-flag2263: - percentage: 63 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 37 + "True": 63 test-flag2264: - percentage: 64 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 36 + "True": 64 test-flag2265: - percentage: 65 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 35 + "True": 65 test-flag2266: - percentage: 66 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 34 + "True": 66 test-flag2267: - percentage: 67 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 33 + "True": 67 test-flag2268: - percentage: 68 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 32 + "True": 68 test-flag2269: - percentage: 69 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 31 + "True": 69 test-flag2270: - percentage: 70 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 30 + "True": 70 test-flag2271: - percentage: 71 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 29 + "True": 71 test-flag2272: - percentage: 72 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 28 + "True": 72 test-flag2273: - percentage: 73 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 27 + "True": 73 test-flag2274: - percentage: 74 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 26 + "True": 74 test-flag2275: - percentage: 75 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 25 + "True": 75 test-flag2276: - percentage: 76 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 24 + "True": 76 test-flag2277: - percentage: 77 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 23 + "True": 77 test-flag2278: - percentage: 78 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 22 + "True": 78 test-flag2279: - percentage: 79 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 21 + "True": 79 test-flag2280: - percentage: 80 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 20 + "True": 80 test-flag2281: - percentage: 81 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 19 + "True": 81 test-flag2282: - percentage: 82 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 18 + "True": 82 test-flag2283: - percentage: 83 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 17 + "True": 83 test-flag2284: - percentage: 84 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 16 + "True": 84 test-flag2285: - percentage: 85 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 15 + "True": 85 test-flag2286: - percentage: 86 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 14 + "True": 86 test-flag2287: - percentage: 87 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 13 + "True": 87 test-flag2288: - percentage: 88 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 12 + "True": 88 test-flag2289: - percentage: 89 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 11 + "True": 89 test-flag2290: - percentage: 90 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 10 + "True": 90 test-flag2291: - percentage: 91 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 9 + "True": 91 test-flag2292: - percentage: 92 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 8 + "True": 92 test-flag2293: - percentage: 93 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 7 + "True": 93 test-flag2294: - percentage: 94 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 6 + "True": 94 test-flag2295: - percentage: 95 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 5 + "True": 95 test-flag2296: - percentage: 96 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 4 + "True": 96 test-flag2297: - percentage: 97 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 3 + "True": 97 test-flag2298: - percentage: 98 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 2 + "True": 98 test-flag2299: - percentage: 99 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 1 + "True": 99 test-flag2300: - percentage: 0 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 100 + "True": 0 test-flag2301: - percentage: 1 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 99 + "True": 1 test-flag2302: - percentage: 2 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 98 + "True": 2 test-flag2303: - percentage: 3 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 97 + "True": 3 test-flag2304: - percentage: 4 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 96 + "True": 4 test-flag2305: - percentage: 5 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 95 + "True": 5 test-flag2306: - percentage: 6 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 94 + "True": 6 test-flag2307: - percentage: 7 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 93 + "True": 7 test-flag2308: - percentage: 8 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 92 + "True": 8 test-flag2309: - percentage: 9 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 91 + "True": 9 test-flag2310: - percentage: 10 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 90 + "True": 10 test-flag2311: - percentage: 11 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 89 + "True": 11 test-flag2312: - percentage: 12 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 88 + "True": 12 test-flag2313: - percentage: 13 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 87 + "True": 13 test-flag2314: - percentage: 14 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 86 + "True": 14 test-flag2315: - percentage: 15 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 85 + "True": 15 test-flag2316: - percentage: 16 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 84 + "True": 16 test-flag2317: - percentage: 17 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 83 + "True": 17 test-flag2318: - percentage: 18 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 82 + "True": 18 test-flag2319: - percentage: 19 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 81 + "True": 19 test-flag2320: - percentage: 20 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 80 + "True": 20 test-flag2321: - percentage: 21 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 79 + "True": 21 test-flag2322: - percentage: 22 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 78 + "True": 22 test-flag2323: - percentage: 23 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 77 + "True": 23 test-flag2324: - percentage: 24 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 76 + "True": 24 test-flag2325: - percentage: 25 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 75 + "True": 25 test-flag2326: - percentage: 26 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 74 + "True": 26 test-flag2327: - percentage: 27 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 73 + "True": 27 test-flag2328: - percentage: 28 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 72 + "True": 28 test-flag2329: - percentage: 29 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 71 + "True": 29 test-flag2330: - percentage: 30 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 70 + "True": 30 test-flag2331: - percentage: 31 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 69 + "True": 31 test-flag2332: - percentage: 32 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 68 + "True": 32 test-flag2333: - percentage: 33 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 67 + "True": 33 test-flag2334: - percentage: 34 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 66 + "True": 34 test-flag2335: - percentage: 35 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 65 + "True": 35 test-flag2336: - percentage: 36 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 64 + "True": 36 test-flag2337: - percentage: 37 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 63 + "True": 37 test-flag2338: - percentage: 38 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 62 + "True": 38 test-flag2339: - percentage: 39 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 61 + "True": 39 test-flag2340: - percentage: 40 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 60 + "True": 40 test-flag2341: - percentage: 41 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 59 + "True": 41 test-flag2342: - percentage: 42 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 58 + "True": 42 test-flag2343: - percentage: 43 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 57 + "True": 43 test-flag2344: - percentage: 44 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 56 + "True": 44 test-flag2345: - percentage: 45 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 55 + "True": 45 test-flag2346: - percentage: 46 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 54 + "True": 46 test-flag2347: - percentage: 47 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 53 + "True": 47 test-flag2348: - percentage: 48 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 52 + "True": 48 test-flag2349: - percentage: 49 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 51 + "True": 49 test-flag2350: - percentage: 50 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 50 + "True": 50 test-flag2351: - percentage: 51 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 49 + "True": 51 test-flag2352: - percentage: 52 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 48 + "True": 52 test-flag2353: - percentage: 53 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 47 + "True": 53 test-flag2354: - percentage: 54 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 46 + "True": 54 test-flag2355: - percentage: 55 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 45 + "True": 55 test-flag2356: - percentage: 56 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 44 + "True": 56 test-flag2357: - percentage: 57 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 43 + "True": 57 test-flag2358: - percentage: 58 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 42 + "True": 58 test-flag2359: - percentage: 59 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 41 + "True": 59 test-flag2360: - percentage: 60 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 40 + "True": 60 test-flag2361: - percentage: 61 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 39 + "True": 61 test-flag2362: - percentage: 62 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 38 + "True": 62 test-flag2363: - percentage: 63 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 37 + "True": 63 test-flag2364: - percentage: 64 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 36 + "True": 64 test-flag2365: - percentage: 65 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 35 + "True": 65 test-flag2366: - percentage: 66 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 34 + "True": 66 test-flag2367: - percentage: 67 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 33 + "True": 67 test-flag2368: - percentage: 68 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 32 + "True": 68 test-flag2369: - percentage: 69 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 31 + "True": 69 test-flag2370: - percentage: 70 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 30 + "True": 70 test-flag2371: - percentage: 71 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 29 + "True": 71 test-flag2372: - percentage: 72 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 28 + "True": 72 test-flag2373: - percentage: 73 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 27 + "True": 73 test-flag2374: - percentage: 74 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 26 + "True": 74 test-flag2375: - percentage: 75 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 25 + "True": 75 test-flag2376: - percentage: 76 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 24 + "True": 76 test-flag2377: - percentage: 77 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 23 + "True": 77 test-flag2378: - percentage: 78 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 22 + "True": 78 test-flag2379: - percentage: 79 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 21 + "True": 79 test-flag2380: - percentage: 80 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 20 + "True": 80 test-flag2381: - percentage: 81 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 19 + "True": 81 test-flag2382: - percentage: 82 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 18 + "True": 82 test-flag2383: - percentage: 83 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 17 + "True": 83 test-flag2384: - percentage: 84 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 16 + "True": 84 test-flag2385: - percentage: 85 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 15 + "True": 85 test-flag2386: - percentage: 86 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 14 + "True": 86 test-flag2387: - percentage: 87 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 13 + "True": 87 test-flag2388: - percentage: 88 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 12 + "True": 88 test-flag2389: - percentage: 89 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 11 + "True": 89 test-flag2390: - percentage: 90 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 10 + "True": 90 test-flag2391: - percentage: 91 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 9 + "True": 91 test-flag2392: - percentage: 92 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 8 + "True": 92 test-flag2393: - percentage: 93 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 7 + "True": 93 test-flag2394: - percentage: 94 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 6 + "True": 94 test-flag2395: - percentage: 95 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 5 + "True": 95 test-flag2396: - percentage: 96 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 4 + "True": 96 test-flag2397: - percentage: 97 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 3 + "True": 97 test-flag2398: - percentage: 98 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 2 + "True": 98 test-flag2399: - percentage: 99 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 1 + "True": 99 test-flag2400: - percentage: 0 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 100 + "True": 0 test-flag2401: - percentage: 1 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 99 + "True": 1 test-flag2402: - percentage: 2 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 98 + "True": 2 test-flag2403: - percentage: 3 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 97 + "True": 3 test-flag2404: - percentage: 4 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 96 + "True": 4 test-flag2405: - percentage: 5 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 95 + "True": 5 test-flag2406: - percentage: 6 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 94 + "True": 6 test-flag2407: - percentage: 7 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 93 + "True": 7 test-flag2408: - percentage: 8 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 92 + "True": 8 test-flag2409: - percentage: 9 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 91 + "True": 9 test-flag2410: - percentage: 10 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 90 + "True": 10 test-flag2411: - percentage: 11 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 89 + "True": 11 test-flag2412: - percentage: 12 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 88 + "True": 12 test-flag2413: - percentage: 13 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 87 + "True": 13 test-flag2414: - percentage: 14 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 86 + "True": 14 test-flag2415: - percentage: 15 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 85 + "True": 15 test-flag2416: - percentage: 16 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 84 + "True": 16 test-flag2417: - percentage: 17 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 83 + "True": 17 test-flag2418: - percentage: 18 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 82 + "True": 18 test-flag2419: - percentage: 19 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 81 + "True": 19 test-flag2420: - percentage: 20 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 80 + "True": 20 test-flag2421: - percentage: 21 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 79 + "True": 21 test-flag2422: - percentage: 22 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 78 + "True": 22 test-flag2423: - percentage: 23 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 77 + "True": 23 test-flag2424: - percentage: 24 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 76 + "True": 24 test-flag2425: - percentage: 25 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 75 + "True": 25 test-flag2426: - percentage: 26 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 74 + "True": 26 test-flag2427: - percentage: 27 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 73 + "True": 27 test-flag2428: - percentage: 28 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 72 + "True": 28 test-flag2429: - percentage: 29 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 71 + "True": 29 test-flag2430: - percentage: 30 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 70 + "True": 30 test-flag2431: - percentage: 31 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 69 + "True": 31 test-flag2432: - percentage: 32 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 68 + "True": 32 test-flag2433: - percentage: 33 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 67 + "True": 33 test-flag2434: - percentage: 34 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 66 + "True": 34 test-flag2435: - percentage: 35 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 65 + "True": 35 test-flag2436: - percentage: 36 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 64 + "True": 36 test-flag2437: - percentage: 37 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 63 + "True": 37 test-flag2438: - percentage: 38 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 62 + "True": 38 test-flag2439: - percentage: 39 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 61 + "True": 39 test-flag2440: - percentage: 40 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 60 + "True": 40 test-flag2441: - percentage: 41 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 59 + "True": 41 test-flag2442: - percentage: 42 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 58 + "True": 42 test-flag2443: - percentage: 43 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 57 + "True": 43 test-flag2444: - percentage: 44 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 56 + "True": 44 test-flag2445: - percentage: 45 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 55 + "True": 45 test-flag2446: - percentage: 46 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 54 + "True": 46 test-flag2447: - percentage: 47 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 53 + "True": 47 test-flag2448: - percentage: 48 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 52 + "True": 48 test-flag2449: - percentage: 49 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 51 + "True": 49 test-flag2450: - percentage: 50 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 50 + "True": 50 test-flag2451: - percentage: 51 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 49 + "True": 51 test-flag2452: - percentage: 52 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 48 + "True": 52 test-flag2453: - percentage: 53 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 47 + "True": 53 test-flag2454: - percentage: 54 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 46 + "True": 54 test-flag2455: - percentage: 55 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 45 + "True": 55 test-flag2456: - percentage: 56 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 44 + "True": 56 test-flag2457: - percentage: 57 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 43 + "True": 57 test-flag2458: - percentage: 58 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 42 + "True": 58 test-flag2459: - percentage: 59 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 41 + "True": 59 test-flag2460: - percentage: 60 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 40 + "True": 60 test-flag2461: - percentage: 61 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 39 + "True": 61 test-flag2462: - percentage: 62 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 38 + "True": 62 test-flag2463: - percentage: 63 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 37 + "True": 63 test-flag2464: - percentage: 64 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 36 + "True": 64 test-flag2465: - percentage: 65 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 35 + "True": 65 test-flag2466: - percentage: 66 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 34 + "True": 66 test-flag2467: - percentage: 67 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 33 + "True": 67 test-flag2468: - percentage: 68 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 32 + "True": 68 test-flag2469: - percentage: 69 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 31 + "True": 69 test-flag2470: - percentage: 70 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 30 + "True": 70 test-flag2471: - percentage: 71 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 29 + "True": 71 test-flag2472: - percentage: 72 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 28 + "True": 72 test-flag2473: - percentage: 73 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 27 + "True": 73 test-flag2474: - percentage: 74 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 26 + "True": 74 test-flag2475: - percentage: 75 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 25 + "True": 75 test-flag2476: - percentage: 76 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 24 + "True": 76 test-flag2477: - percentage: 77 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 23 + "True": 77 test-flag2478: - percentage: 78 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 22 + "True": 78 test-flag2479: - percentage: 79 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 21 + "True": 79 test-flag2480: - percentage: 80 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 20 + "True": 80 test-flag2481: - percentage: 81 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 19 + "True": 81 test-flag2482: - percentage: 82 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 18 + "True": 82 test-flag2483: - percentage: 83 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 17 + "True": 83 test-flag2484: - percentage: 84 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 16 + "True": 84 test-flag2485: - percentage: 85 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 15 + "True": 85 test-flag2486: - percentage: 86 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 14 + "True": 86 test-flag2487: - percentage: 87 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 13 + "True": 87 test-flag2488: - percentage: 88 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 12 + "True": 88 test-flag2489: - percentage: 89 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 11 + "True": 89 test-flag2490: - percentage: 90 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 10 + "True": 90 test-flag2491: - percentage: 91 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 9 + "True": 91 test-flag2492: - percentage: 92 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 8 + "True": 92 test-flag2493: - percentage: 93 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 7 + "True": 93 test-flag2494: - percentage: 94 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 6 + "True": 94 test-flag2495: - percentage: 95 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 5 + "True": 95 test-flag2496: - percentage: 96 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 4 + "True": 96 test-flag2497: - percentage: 97 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 3 + "True": 97 test-flag2498: - percentage: 98 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 2 + "True": 98 test-flag2499: - percentage: 99 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 1 + "True": 99 test-flag2500: - percentage: 0 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 100 + "True": 0 test-flag2501: - percentage: 1 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 99 + "True": 1 test-flag2502: - percentage: 2 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 98 + "True": 2 test-flag2503: - percentage: 3 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 97 + "True": 3 test-flag2504: - percentage: 4 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 96 + "True": 4 test-flag2505: - percentage: 5 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 95 + "True": 5 test-flag2506: - percentage: 6 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 94 + "True": 6 test-flag2507: - percentage: 7 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 93 + "True": 7 test-flag2508: - percentage: 8 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 92 + "True": 8 test-flag2509: - percentage: 9 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 91 + "True": 9 test-flag2510: - percentage: 10 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 90 + "True": 10 test-flag2511: - percentage: 11 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 89 + "True": 11 test-flag2512: - percentage: 12 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 88 + "True": 12 test-flag2513: - percentage: 13 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 87 + "True": 13 test-flag2514: - percentage: 14 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 86 + "True": 14 test-flag2515: - percentage: 15 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 85 + "True": 15 test-flag2516: - percentage: 16 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 84 + "True": 16 test-flag2517: - percentage: 17 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 83 + "True": 17 test-flag2518: - percentage: 18 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 82 + "True": 18 test-flag2519: - percentage: 19 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 81 + "True": 19 test-flag2520: - percentage: 20 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 80 + "True": 20 test-flag2521: - percentage: 21 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 79 + "True": 21 test-flag2522: - percentage: 22 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 78 + "True": 22 test-flag2523: - percentage: 23 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 77 + "True": 23 test-flag2524: - percentage: 24 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 76 + "True": 24 test-flag2525: - percentage: 25 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 75 + "True": 25 test-flag2526: - percentage: 26 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 74 + "True": 26 test-flag2527: - percentage: 27 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 73 + "True": 27 test-flag2528: - percentage: 28 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 72 + "True": 28 test-flag2529: - percentage: 29 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 71 + "True": 29 test-flag2530: - percentage: 30 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 70 + "True": 30 test-flag2531: - percentage: 31 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 69 + "True": 31 test-flag2532: - percentage: 32 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 68 + "True": 32 test-flag2533: - percentage: 33 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 67 + "True": 33 test-flag2534: - percentage: 34 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 66 + "True": 34 test-flag2535: - percentage: 35 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 65 + "True": 35 test-flag2536: - percentage: 36 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 64 + "True": 36 test-flag2537: - percentage: 37 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 63 + "True": 37 test-flag2538: - percentage: 38 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 62 + "True": 38 test-flag2539: - percentage: 39 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 61 + "True": 39 test-flag2540: - percentage: 40 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 60 + "True": 40 test-flag2541: - percentage: 41 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 59 + "True": 41 test-flag2542: - percentage: 42 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 58 + "True": 42 test-flag2543: - percentage: 43 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 57 + "True": 43 test-flag2544: - percentage: 44 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 56 + "True": 44 test-flag2545: - percentage: 45 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 55 + "True": 45 test-flag2546: - percentage: 46 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 54 + "True": 46 test-flag2547: - percentage: 47 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 53 + "True": 47 test-flag2548: - percentage: 48 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 52 + "True": 48 test-flag2549: - percentage: 49 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 51 + "True": 49 test-flag2550: - percentage: 50 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 50 + "True": 50 test-flag2551: - percentage: 51 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 49 + "True": 51 test-flag2552: - percentage: 52 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 48 + "True": 52 test-flag2553: - percentage: 53 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 47 + "True": 53 test-flag2554: - percentage: 54 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 46 + "True": 54 test-flag2555: - percentage: 55 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 45 + "True": 55 test-flag2556: - percentage: 56 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 44 + "True": 56 test-flag2557: - percentage: 57 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 43 + "True": 57 test-flag2558: - percentage: 58 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 42 + "True": 58 test-flag2559: - percentage: 59 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 41 + "True": 59 test-flag2560: - percentage: 60 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 40 + "True": 60 test-flag2561: - percentage: 61 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 39 + "True": 61 test-flag2562: - percentage: 62 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 38 + "True": 62 test-flag2563: - percentage: 63 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 37 + "True": 63 test-flag2564: - percentage: 64 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 36 + "True": 64 test-flag2565: - percentage: 65 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 35 + "True": 65 test-flag2566: - percentage: 66 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 34 + "True": 66 test-flag2567: - percentage: 67 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 33 + "True": 67 test-flag2568: - percentage: 68 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 32 + "True": 68 test-flag2569: - percentage: 69 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 31 + "True": 69 test-flag2570: - percentage: 70 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 30 + "True": 70 test-flag2571: - percentage: 71 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 29 + "True": 71 test-flag2572: - percentage: 72 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 28 + "True": 72 test-flag2573: - percentage: 73 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 27 + "True": 73 test-flag2574: - percentage: 74 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 26 + "True": 74 test-flag2575: - percentage: 75 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 25 + "True": 75 test-flag2576: - percentage: 76 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 24 + "True": 76 test-flag2577: - percentage: 77 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 23 + "True": 77 test-flag2578: - percentage: 78 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 22 + "True": 78 test-flag2579: - percentage: 79 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 21 + "True": 79 test-flag2580: - percentage: 80 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 20 + "True": 80 test-flag2581: - percentage: 81 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 19 + "True": 81 test-flag2582: - percentage: 82 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 18 + "True": 82 test-flag2583: - percentage: 83 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 17 + "True": 83 test-flag2584: - percentage: 84 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 16 + "True": 84 test-flag2585: - percentage: 85 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 15 + "True": 85 test-flag2586: - percentage: 86 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 14 + "True": 86 test-flag2587: - percentage: 87 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 13 + "True": 87 test-flag2588: - percentage: 88 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 12 + "True": 88 test-flag2589: - percentage: 89 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 11 + "True": 89 test-flag2590: - percentage: 90 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 10 + "True": 90 test-flag2591: - percentage: 91 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 9 + "True": 91 test-flag2592: - percentage: 92 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 8 + "True": 92 test-flag2593: - percentage: 93 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 7 + "True": 93 test-flag2594: - percentage: 94 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 6 + "True": 94 test-flag2595: - percentage: 95 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 5 + "True": 95 test-flag2596: - percentage: 96 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 4 + "True": 96 test-flag2597: - percentage: 97 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 3 + "True": 97 test-flag2598: - percentage: 98 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 2 + "True": 98 test-flag2599: - percentage: 99 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 1 + "True": 99 test-flag2600: - percentage: 0 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 100 + "True": 0 test-flag2601: - percentage: 1 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 99 + "True": 1 test-flag2602: - percentage: 2 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 98 + "True": 2 test-flag2603: - percentage: 3 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 97 + "True": 3 test-flag2604: - percentage: 4 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 96 + "True": 4 test-flag2605: - percentage: 5 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 95 + "True": 5 test-flag2606: - percentage: 6 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 94 + "True": 6 test-flag2607: - percentage: 7 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 93 + "True": 7 test-flag2608: - percentage: 8 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 92 + "True": 8 test-flag2609: - percentage: 9 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 91 + "True": 9 test-flag2610: - percentage: 10 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 90 + "True": 10 test-flag2611: - percentage: 11 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 89 + "True": 11 test-flag2612: - percentage: 12 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 88 + "True": 12 test-flag2613: - percentage: 13 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 87 + "True": 13 test-flag2614: - percentage: 14 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 86 + "True": 14 test-flag2615: - percentage: 15 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 85 + "True": 15 test-flag2616: - percentage: 16 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 84 + "True": 16 test-flag2617: - percentage: 17 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 83 + "True": 17 test-flag2618: - percentage: 18 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 82 + "True": 18 test-flag2619: - percentage: 19 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 81 + "True": 19 test-flag2620: - percentage: 20 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 80 + "True": 20 test-flag2621: - percentage: 21 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 79 + "True": 21 test-flag2622: - percentage: 22 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 78 + "True": 22 test-flag2623: - percentage: 23 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 77 + "True": 23 test-flag2624: - percentage: 24 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 76 + "True": 24 test-flag2625: - percentage: 25 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 75 + "True": 25 test-flag2626: - percentage: 26 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 74 + "True": 26 test-flag2627: - percentage: 27 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 73 + "True": 27 test-flag2628: - percentage: 28 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 72 + "True": 28 test-flag2629: - percentage: 29 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 71 + "True": 29 test-flag2630: - percentage: 30 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 70 + "True": 30 test-flag2631: - percentage: 31 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 69 + "True": 31 test-flag2632: - percentage: 32 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 68 + "True": 32 test-flag2633: - percentage: 33 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 67 + "True": 33 test-flag2634: - percentage: 34 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 66 + "True": 34 test-flag2635: - percentage: 35 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 65 + "True": 35 test-flag2636: - percentage: 36 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 64 + "True": 36 test-flag2637: - percentage: 37 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 63 + "True": 37 test-flag2638: - percentage: 38 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 62 + "True": 38 test-flag2639: - percentage: 39 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 61 + "True": 39 test-flag2640: - percentage: 40 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 60 + "True": 40 test-flag2641: - percentage: 41 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 59 + "True": 41 test-flag2642: - percentage: 42 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 58 + "True": 42 test-flag2643: - percentage: 43 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 57 + "True": 43 test-flag2644: - percentage: 44 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 56 + "True": 44 test-flag2645: - percentage: 45 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 55 + "True": 45 test-flag2646: - percentage: 46 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 54 + "True": 46 test-flag2647: - percentage: 47 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 53 + "True": 47 test-flag2648: - percentage: 48 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 52 + "True": 48 test-flag2649: - percentage: 49 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 51 + "True": 49 test-flag2650: - percentage: 50 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 50 + "True": 50 test-flag2651: - percentage: 51 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 49 + "True": 51 test-flag2652: - percentage: 52 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 48 + "True": 52 test-flag2653: - percentage: 53 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 47 + "True": 53 test-flag2654: - percentage: 54 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 46 + "True": 54 test-flag2655: - percentage: 55 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 45 + "True": 55 test-flag2656: - percentage: 56 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 44 + "True": 56 test-flag2657: - percentage: 57 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 43 + "True": 57 test-flag2658: - percentage: 58 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 42 + "True": 58 test-flag2659: - percentage: 59 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 41 + "True": 59 test-flag2660: - percentage: 60 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 40 + "True": 60 test-flag2661: - percentage: 61 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 39 + "True": 61 test-flag2662: - percentage: 62 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 38 + "True": 62 test-flag2663: - percentage: 63 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 37 + "True": 63 test-flag2664: - percentage: 64 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 36 + "True": 64 test-flag2665: - percentage: 65 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 35 + "True": 65 test-flag2666: - percentage: 66 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 34 + "True": 66 test-flag2667: - percentage: 67 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 33 + "True": 67 test-flag2668: - percentage: 68 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 32 + "True": 68 test-flag2669: - percentage: 69 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 31 + "True": 69 test-flag2670: - percentage: 70 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 30 + "True": 70 test-flag2671: - percentage: 71 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 29 + "True": 71 test-flag2672: - percentage: 72 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 28 + "True": 72 test-flag2673: - percentage: 73 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 27 + "True": 73 test-flag2674: - percentage: 74 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 26 + "True": 74 test-flag2675: - percentage: 75 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 25 + "True": 75 test-flag2676: - percentage: 76 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 24 + "True": 76 test-flag2677: - percentage: 77 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 23 + "True": 77 test-flag2678: - percentage: 78 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 22 + "True": 78 test-flag2679: - percentage: 79 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 21 + "True": 79 test-flag2680: - percentage: 80 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 20 + "True": 80 test-flag2681: - percentage: 81 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 19 + "True": 81 test-flag2682: - percentage: 82 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 18 + "True": 82 test-flag2683: - percentage: 83 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 17 + "True": 83 test-flag2684: - percentage: 84 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 16 + "True": 84 test-flag2685: - percentage: 85 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 15 + "True": 85 test-flag2686: - percentage: 86 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 14 + "True": 86 test-flag2687: - percentage: 87 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 13 + "True": 87 test-flag2688: - percentage: 88 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 12 + "True": 88 test-flag2689: - percentage: 89 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 11 + "True": 89 test-flag2690: - percentage: 90 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 10 + "True": 90 test-flag2691: - percentage: 91 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 9 + "True": 91 test-flag2692: - percentage: 92 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 8 + "True": 92 test-flag2693: - percentage: 93 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 7 + "True": 93 test-flag2694: - percentage: 94 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 6 + "True": 94 test-flag2695: - percentage: 95 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 5 + "True": 95 test-flag2696: - percentage: 96 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 4 + "True": 96 test-flag2697: - percentage: 97 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 3 + "True": 97 test-flag2698: - percentage: 98 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 2 + "True": 98 test-flag2699: - percentage: 99 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 1 + "True": 99 test-flag2700: - percentage: 0 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 100 + "True": 0 test-flag2701: - percentage: 1 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 99 + "True": 1 test-flag2702: - percentage: 2 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 98 + "True": 2 test-flag2703: - percentage: 3 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 97 + "True": 3 test-flag2704: - percentage: 4 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 96 + "True": 4 test-flag2705: - percentage: 5 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 95 + "True": 5 test-flag2706: - percentage: 6 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 94 + "True": 6 test-flag2707: - percentage: 7 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 93 + "True": 7 test-flag2708: - percentage: 8 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 92 + "True": 8 test-flag2709: - percentage: 9 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 91 + "True": 9 test-flag2710: - percentage: 10 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 90 + "True": 10 test-flag2711: - percentage: 11 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 89 + "True": 11 test-flag2712: - percentage: 12 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 88 + "True": 12 test-flag2713: - percentage: 13 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 87 + "True": 13 test-flag2714: - percentage: 14 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 86 + "True": 14 test-flag2715: - percentage: 15 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 85 + "True": 15 test-flag2716: - percentage: 16 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 84 + "True": 16 test-flag2717: - percentage: 17 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 83 + "True": 17 test-flag2718: - percentage: 18 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 82 + "True": 18 test-flag2719: - percentage: 19 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 81 + "True": 19 test-flag2720: - percentage: 20 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 80 + "True": 20 test-flag2721: - percentage: 21 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 79 + "True": 21 test-flag2722: - percentage: 22 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 78 + "True": 22 test-flag2723: - percentage: 23 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 77 + "True": 23 test-flag2724: - percentage: 24 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 76 + "True": 24 test-flag2725: - percentage: 25 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 75 + "True": 25 test-flag2726: - percentage: 26 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 74 + "True": 26 test-flag2727: - percentage: 27 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 73 + "True": 27 test-flag2728: - percentage: 28 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 72 + "True": 28 test-flag2729: - percentage: 29 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 71 + "True": 29 test-flag2730: - percentage: 30 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 70 + "True": 30 test-flag2731: - percentage: 31 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 69 + "True": 31 test-flag2732: - percentage: 32 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 68 + "True": 32 test-flag2733: - percentage: 33 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 67 + "True": 33 test-flag2734: - percentage: 34 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 66 + "True": 34 test-flag2735: - percentage: 35 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 65 + "True": 35 test-flag2736: - percentage: 36 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 64 + "True": 36 test-flag2737: - percentage: 37 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 63 + "True": 37 test-flag2738: - percentage: 38 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 62 + "True": 38 test-flag2739: - percentage: 39 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 61 + "True": 39 test-flag2740: - percentage: 40 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 60 + "True": 40 test-flag2741: - percentage: 41 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 59 + "True": 41 test-flag2742: - percentage: 42 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 58 + "True": 42 test-flag2743: - percentage: 43 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 57 + "True": 43 test-flag2744: - percentage: 44 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 56 + "True": 44 test-flag2745: - percentage: 45 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 55 + "True": 45 test-flag2746: - percentage: 46 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 54 + "True": 46 test-flag2747: - percentage: 47 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 53 + "True": 47 test-flag2748: - percentage: 48 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 52 + "True": 48 test-flag2749: - percentage: 49 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 51 + "True": 49 test-flag2750: - percentage: 50 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 50 + "True": 50 test-flag2751: - percentage: 51 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 49 + "True": 51 test-flag2752: - percentage: 52 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 48 + "True": 52 test-flag2753: - percentage: 53 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 47 + "True": 53 test-flag2754: - percentage: 54 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 46 + "True": 54 test-flag2755: - percentage: 55 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 45 + "True": 55 test-flag2756: - percentage: 56 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 44 + "True": 56 test-flag2757: - percentage: 57 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 43 + "True": 57 test-flag2758: - percentage: 58 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 42 + "True": 58 test-flag2759: - percentage: 59 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 41 + "True": 59 test-flag2760: - percentage: 60 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 40 + "True": 60 test-flag2761: - percentage: 61 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 39 + "True": 61 test-flag2762: - percentage: 62 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 38 + "True": 62 test-flag2763: - percentage: 63 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 37 + "True": 63 test-flag2764: - percentage: 64 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 36 + "True": 64 test-flag2765: - percentage: 65 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 35 + "True": 65 test-flag2766: - percentage: 66 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 34 + "True": 66 test-flag2767: - percentage: 67 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 33 + "True": 67 test-flag2768: - percentage: 68 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 32 + "True": 68 test-flag2769: - percentage: 69 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 31 + "True": 69 test-flag2770: - percentage: 70 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 30 + "True": 70 test-flag2771: - percentage: 71 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 29 + "True": 71 test-flag2772: - percentage: 72 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 28 + "True": 72 test-flag2773: - percentage: 73 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 27 + "True": 73 test-flag2774: - percentage: 74 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 26 + "True": 74 test-flag2775: - percentage: 75 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 25 + "True": 75 test-flag2776: - percentage: 76 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 24 + "True": 76 test-flag2777: - percentage: 77 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 23 + "True": 77 test-flag2778: - percentage: 78 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 22 + "True": 78 test-flag2779: - percentage: 79 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 21 + "True": 79 test-flag2780: - percentage: 80 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 20 + "True": 80 test-flag2781: - percentage: 81 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 19 + "True": 81 test-flag2782: - percentage: 82 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 18 + "True": 82 test-flag2783: - percentage: 83 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 17 + "True": 83 test-flag2784: - percentage: 84 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 16 + "True": 84 test-flag2785: - percentage: 85 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 15 + "True": 85 test-flag2786: - percentage: 86 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 14 + "True": 86 test-flag2787: - percentage: 87 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 13 + "True": 87 test-flag2788: - percentage: 88 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 12 + "True": 88 test-flag2789: - percentage: 89 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 11 + "True": 89 test-flag2790: - percentage: 90 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 10 + "True": 90 test-flag2791: - percentage: 91 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 9 + "True": 91 test-flag2792: - percentage: 92 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 8 + "True": 92 test-flag2793: - percentage: 93 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 7 + "True": 93 test-flag2794: - percentage: 94 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 6 + "True": 94 test-flag2795: - percentage: 95 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 5 + "True": 95 test-flag2796: - percentage: 96 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 4 + "True": 96 test-flag2797: - percentage: 97 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 3 + "True": 97 test-flag2798: - percentage: 98 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 2 + "True": 98 test-flag2799: - percentage: 99 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 1 + "True": 99 test-flag2800: - percentage: 0 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 100 + "True": 0 test-flag2801: - percentage: 1 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 99 + "True": 1 test-flag2802: - percentage: 2 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 98 + "True": 2 test-flag2803: - percentage: 3 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 97 + "True": 3 test-flag2804: - percentage: 4 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 96 + "True": 4 test-flag2805: - percentage: 5 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 95 + "True": 5 test-flag2806: - percentage: 6 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 94 + "True": 6 test-flag2807: - percentage: 7 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 93 + "True": 7 test-flag2808: - percentage: 8 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 92 + "True": 8 test-flag2809: - percentage: 9 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 91 + "True": 9 test-flag2810: - percentage: 10 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 90 + "True": 10 test-flag2811: - percentage: 11 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 89 + "True": 11 test-flag2812: - percentage: 12 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 88 + "True": 12 test-flag2813: - percentage: 13 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 87 + "True": 13 test-flag2814: - percentage: 14 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 86 + "True": 14 test-flag2815: - percentage: 15 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 85 + "True": 15 test-flag2816: - percentage: 16 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 84 + "True": 16 test-flag2817: - percentage: 17 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 83 + "True": 17 test-flag2818: - percentage: 18 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 82 + "True": 18 test-flag2819: - percentage: 19 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 81 + "True": 19 test-flag2820: - percentage: 20 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 80 + "True": 20 test-flag2821: - percentage: 21 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 79 + "True": 21 test-flag2822: - percentage: 22 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 78 + "True": 22 test-flag2823: - percentage: 23 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 77 + "True": 23 test-flag2824: - percentage: 24 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 76 + "True": 24 test-flag2825: - percentage: 25 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 75 + "True": 25 test-flag2826: - percentage: 26 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 74 + "True": 26 test-flag2827: - percentage: 27 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 73 + "True": 27 test-flag2828: - percentage: 28 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 72 + "True": 28 test-flag2829: - percentage: 29 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 71 + "True": 29 test-flag2830: - percentage: 30 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 70 + "True": 30 test-flag2831: - percentage: 31 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 69 + "True": 31 test-flag2832: - percentage: 32 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 68 + "True": 32 test-flag2833: - percentage: 33 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 67 + "True": 33 test-flag2834: - percentage: 34 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 66 + "True": 34 test-flag2835: - percentage: 35 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 65 + "True": 35 test-flag2836: - percentage: 36 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 64 + "True": 36 test-flag2837: - percentage: 37 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 63 + "True": 37 test-flag2838: - percentage: 38 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 62 + "True": 38 test-flag2839: - percentage: 39 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 61 + "True": 39 test-flag2840: - percentage: 40 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 60 + "True": 40 test-flag2841: - percentage: 41 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 59 + "True": 41 test-flag2842: - percentage: 42 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 58 + "True": 42 test-flag2843: - percentage: 43 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 57 + "True": 43 test-flag2844: - percentage: 44 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 56 + "True": 44 test-flag2845: - percentage: 45 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 55 + "True": 45 test-flag2846: - percentage: 46 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 54 + "True": 46 test-flag2847: - percentage: 47 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 53 + "True": 47 test-flag2848: - percentage: 48 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 52 + "True": 48 test-flag2849: - percentage: 49 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 51 + "True": 49 test-flag2850: - percentage: 50 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 50 + "True": 50 test-flag2851: - percentage: 51 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 49 + "True": 51 test-flag2852: - percentage: 52 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 48 + "True": 52 test-flag2853: - percentage: 53 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 47 + "True": 53 test-flag2854: - percentage: 54 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 46 + "True": 54 test-flag2855: - percentage: 55 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 45 + "True": 55 test-flag2856: - percentage: 56 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 44 + "True": 56 test-flag2857: - percentage: 57 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 43 + "True": 57 test-flag2858: - percentage: 58 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 42 + "True": 58 test-flag2859: - percentage: 59 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 41 + "True": 59 test-flag2860: - percentage: 60 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 40 + "True": 60 test-flag2861: - percentage: 61 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 39 + "True": 61 test-flag2862: - percentage: 62 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 38 + "True": 62 test-flag2863: - percentage: 63 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 37 + "True": 63 test-flag2864: - percentage: 64 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 36 + "True": 64 test-flag2865: - percentage: 65 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 35 + "True": 65 test-flag2866: - percentage: 66 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 34 + "True": 66 test-flag2867: - percentage: 67 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 33 + "True": 67 test-flag2868: - percentage: 68 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 32 + "True": 68 test-flag2869: - percentage: 69 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 31 + "True": 69 test-flag2870: - percentage: 70 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 30 + "True": 70 test-flag2871: - percentage: 71 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 29 + "True": 71 test-flag2872: - percentage: 72 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 28 + "True": 72 test-flag2873: - percentage: 73 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 27 + "True": 73 test-flag2874: - percentage: 74 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 26 + "True": 74 test-flag2875: - percentage: 75 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 25 + "True": 75 test-flag2876: - percentage: 76 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 24 + "True": 76 test-flag2877: - percentage: 77 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 23 + "True": 77 test-flag2878: - percentage: 78 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 22 + "True": 78 test-flag2879: - percentage: 79 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 21 + "True": 79 test-flag2880: - percentage: 80 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 20 + "True": 80 test-flag2881: - percentage: 81 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 19 + "True": 81 test-flag2882: - percentage: 82 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 18 + "True": 82 test-flag2883: - percentage: 83 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 17 + "True": 83 test-flag2884: - percentage: 84 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 16 + "True": 84 test-flag2885: - percentage: 85 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 15 + "True": 85 test-flag2886: - percentage: 86 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 14 + "True": 86 test-flag2887: - percentage: 87 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 13 + "True": 87 test-flag2888: - percentage: 88 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 12 + "True": 88 test-flag2889: - percentage: 89 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 11 + "True": 89 test-flag2890: - percentage: 90 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 10 + "True": 90 test-flag2891: - percentage: 91 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 9 + "True": 91 test-flag2892: - percentage: 92 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 8 + "True": 92 test-flag2893: - percentage: 93 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 7 + "True": 93 test-flag2894: - percentage: 94 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 6 + "True": 94 test-flag2895: - percentage: 95 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 5 + "True": 95 test-flag2896: - percentage: 96 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 4 + "True": 96 test-flag2897: - percentage: 97 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 3 + "True": 97 test-flag2898: - percentage: 98 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 2 + "True": 98 test-flag2899: - percentage: 99 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 1 + "True": 99 test-flag2900: - percentage: 0 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 100 + "True": 0 test-flag2901: - percentage: 1 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 99 + "True": 1 test-flag2902: - percentage: 2 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 98 + "True": 2 test-flag2903: - percentage: 3 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 97 + "True": 3 test-flag2904: - percentage: 4 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 96 + "True": 4 test-flag2905: - percentage: 5 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 95 + "True": 5 test-flag2906: - percentage: 6 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 94 + "True": 6 test-flag2907: - percentage: 7 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 93 + "True": 7 test-flag2908: - percentage: 8 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 92 + "True": 8 test-flag2909: - percentage: 9 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 91 + "True": 9 test-flag2910: - percentage: 10 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 90 + "True": 10 test-flag2911: - percentage: 11 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 89 + "True": 11 test-flag2912: - percentage: 12 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 88 + "True": 12 test-flag2913: - percentage: 13 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 87 + "True": 13 test-flag2914: - percentage: 14 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 86 + "True": 14 test-flag2915: - percentage: 15 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 85 + "True": 15 test-flag2916: - percentage: 16 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 84 + "True": 16 test-flag2917: - percentage: 17 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 83 + "True": 17 test-flag2918: - percentage: 18 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 82 + "True": 18 test-flag2919: - percentage: 19 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 81 + "True": 19 test-flag2920: - percentage: 20 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 80 + "True": 20 test-flag2921: - percentage: 21 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 79 + "True": 21 test-flag2922: - percentage: 22 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 78 + "True": 22 test-flag2923: - percentage: 23 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 77 + "True": 23 test-flag2924: - percentage: 24 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 76 + "True": 24 test-flag2925: - percentage: 25 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 75 + "True": 25 test-flag2926: - percentage: 26 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 74 + "True": 26 test-flag2927: - percentage: 27 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 73 + "True": 27 test-flag2928: - percentage: 28 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 72 + "True": 28 test-flag2929: - percentage: 29 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 71 + "True": 29 test-flag2930: - percentage: 30 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 70 + "True": 30 test-flag2931: - percentage: 31 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 69 + "True": 31 test-flag2932: - percentage: 32 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 68 + "True": 32 test-flag2933: - percentage: 33 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 67 + "True": 33 test-flag2934: - percentage: 34 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 66 + "True": 34 test-flag2935: - percentage: 35 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 65 + "True": 35 test-flag2936: - percentage: 36 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 64 + "True": 36 test-flag2937: - percentage: 37 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 63 + "True": 37 test-flag2938: - percentage: 38 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 62 + "True": 38 test-flag2939: - percentage: 39 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 61 + "True": 39 test-flag2940: - percentage: 40 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 60 + "True": 40 test-flag2941: - percentage: 41 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 59 + "True": 41 test-flag2942: - percentage: 42 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 58 + "True": 42 test-flag2943: - percentage: 43 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 57 + "True": 43 test-flag2944: - percentage: 44 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 56 + "True": 44 test-flag2945: - percentage: 45 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 55 + "True": 45 test-flag2946: - percentage: 46 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 54 + "True": 46 test-flag2947: - percentage: 47 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 53 + "True": 47 test-flag2948: - percentage: 48 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 52 + "True": 48 test-flag2949: - percentage: 49 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 51 + "True": 49 test-flag2950: - percentage: 50 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 50 + "True": 50 test-flag2951: - percentage: 51 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 49 + "True": 51 test-flag2952: - percentage: 52 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 48 + "True": 52 test-flag2953: - percentage: 53 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 47 + "True": 53 test-flag2954: - percentage: 54 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 46 + "True": 54 test-flag2955: - percentage: 55 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 45 + "True": 55 test-flag2956: - percentage: 56 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 44 + "True": 56 test-flag2957: - percentage: 57 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 43 + "True": 57 test-flag2958: - percentage: 58 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 42 + "True": 58 test-flag2959: - percentage: 59 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 41 + "True": 59 test-flag2960: - percentage: 60 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 40 + "True": 60 test-flag2961: - percentage: 61 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 39 + "True": 61 test-flag2962: - percentage: 62 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 38 + "True": 62 test-flag2963: - percentage: 63 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 37 + "True": 63 test-flag2964: - percentage: 64 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 36 + "True": 64 test-flag2965: - percentage: 65 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 35 + "True": 65 test-flag2966: - percentage: 66 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 34 + "True": 66 test-flag2967: - percentage: 67 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 33 + "True": 67 test-flag2968: - percentage: 68 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 32 + "True": 68 test-flag2969: - percentage: 69 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 31 + "True": 69 test-flag2970: - percentage: 70 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 30 + "True": 70 test-flag2971: - percentage: 71 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 29 + "True": 71 test-flag2972: - percentage: 72 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 28 + "True": 72 test-flag2973: - percentage: 73 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 27 + "True": 73 test-flag2974: - percentage: 74 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 26 + "True": 74 test-flag2975: - percentage: 75 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 25 + "True": 75 test-flag2976: - percentage: 76 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 24 + "True": 76 test-flag2977: - percentage: 77 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 23 + "True": 77 test-flag2978: - percentage: 78 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 22 + "True": 78 test-flag2979: - percentage: 79 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 21 + "True": 79 test-flag2980: - percentage: 80 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 20 + "True": 80 test-flag2981: - percentage: 81 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 19 + "True": 81 test-flag2982: - percentage: 82 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 18 + "True": 82 test-flag2983: - percentage: 83 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 17 + "True": 83 test-flag2984: - percentage: 84 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 16 + "True": 84 test-flag2985: - percentage: 85 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 15 + "True": 85 test-flag2986: - percentage: 86 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 14 + "True": 86 test-flag2987: - percentage: 87 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 13 + "True": 87 test-flag2988: - percentage: 88 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 12 + "True": 88 test-flag2989: - percentage: 89 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 11 + "True": 89 test-flag2990: - percentage: 90 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 10 + "True": 90 test-flag2991: - percentage: 91 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 9 + "True": 91 test-flag2992: - percentage: 92 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 8 + "True": 92 test-flag2993: - percentage: 93 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 7 + "True": 93 test-flag2994: - percentage: 94 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 6 + "True": 94 test-flag2995: - percentage: 95 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 5 + "True": 95 test-flag2996: - percentage: 96 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 4 + "True": 96 test-flag2997: - percentage: 97 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 3 + "True": 97 test-flag2998: - percentage: 98 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 2 + "True": 98 test-flag2999: - percentage: 99 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 1 + "True": 99 test-flag3000: - percentage: 0 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 100 + "True": 0 test-flag3001: - percentage: 1 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 99 + "True": 1 test-flag3002: - percentage: 2 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 98 + "True": 2 test-flag3003: - percentage: 3 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 97 + "True": 3 test-flag3004: - percentage: 4 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 96 + "True": 4 test-flag3005: - percentage: 5 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 95 + "True": 5 test-flag3006: - percentage: 6 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 94 + "True": 6 test-flag3007: - percentage: 7 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 93 + "True": 7 test-flag3008: - percentage: 8 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 92 + "True": 8 test-flag3009: - percentage: 9 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 91 + "True": 9 test-flag3010: - percentage: 10 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 90 + "True": 10 test-flag3011: - percentage: 11 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 89 + "True": 11 test-flag3012: - percentage: 12 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 88 + "True": 12 test-flag3013: - percentage: 13 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 87 + "True": 13 test-flag3014: - percentage: 14 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 86 + "True": 14 test-flag3015: - percentage: 15 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 85 + "True": 15 test-flag3016: - percentage: 16 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 84 + "True": 16 test-flag3017: - percentage: 17 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 83 + "True": 17 test-flag3018: - percentage: 18 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 82 + "True": 18 test-flag3019: - percentage: 19 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 81 + "True": 19 test-flag3020: - percentage: 20 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 80 + "True": 20 test-flag3021: - percentage: 21 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 79 + "True": 21 test-flag3022: - percentage: 22 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 78 + "True": 22 test-flag3023: - percentage: 23 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 77 + "True": 23 test-flag3024: - percentage: 24 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 76 + "True": 24 test-flag3025: - percentage: 25 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 75 + "True": 25 test-flag3026: - percentage: 26 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 74 + "True": 26 test-flag3027: - percentage: 27 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 73 + "True": 27 test-flag3028: - percentage: 28 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 72 + "True": 28 test-flag3029: - percentage: 29 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 71 + "True": 29 test-flag3030: - percentage: 30 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 70 + "True": 30 test-flag3031: - percentage: 31 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 69 + "True": 31 test-flag3032: - percentage: 32 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 68 + "True": 32 test-flag3033: - percentage: 33 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 67 + "True": 33 test-flag3034: - percentage: 34 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 66 + "True": 34 test-flag3035: - percentage: 35 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 65 + "True": 35 test-flag3036: - percentage: 36 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 64 + "True": 36 test-flag3037: - percentage: 37 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 63 + "True": 37 test-flag3038: - percentage: 38 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 62 + "True": 38 test-flag3039: - percentage: 39 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 61 + "True": 39 test-flag3040: - percentage: 40 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 60 + "True": 40 test-flag3041: - percentage: 41 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 59 + "True": 41 test-flag3042: - percentage: 42 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 58 + "True": 42 test-flag3043: - percentage: 43 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 57 + "True": 43 test-flag3044: - percentage: 44 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 56 + "True": 44 test-flag3045: - percentage: 45 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 55 + "True": 45 test-flag3046: - percentage: 46 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 54 + "True": 46 test-flag3047: - percentage: 47 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 53 + "True": 47 test-flag3048: - percentage: 48 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 52 + "True": 48 test-flag3049: - percentage: 49 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 51 + "True": 49 test-flag3050: - percentage: 50 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 50 + "True": 50 test-flag3051: - percentage: 51 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 49 + "True": 51 test-flag3052: - percentage: 52 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 48 + "True": 52 test-flag3053: - percentage: 53 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 47 + "True": 53 test-flag3054: - percentage: 54 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 46 + "True": 54 test-flag3055: - percentage: 55 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 45 + "True": 55 test-flag3056: - percentage: 56 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 44 + "True": 56 test-flag3057: - percentage: 57 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 43 + "True": 57 test-flag3058: - percentage: 58 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 42 + "True": 58 test-flag3059: - percentage: 59 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 41 + "True": 59 test-flag3060: - percentage: 60 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 40 + "True": 60 test-flag3061: - percentage: 61 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 39 + "True": 61 test-flag3062: - percentage: 62 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 38 + "True": 62 test-flag3063: - percentage: 63 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 37 + "True": 63 test-flag3064: - percentage: 64 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 36 + "True": 64 test-flag3065: - percentage: 65 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 35 + "True": 65 test-flag3066: - percentage: 66 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 34 + "True": 66 test-flag3067: - percentage: 67 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 33 + "True": 67 test-flag3068: - percentage: 68 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 32 + "True": 68 test-flag3069: - percentage: 69 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 31 + "True": 69 test-flag3070: - percentage: 70 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 30 + "True": 70 test-flag3071: - percentage: 71 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 29 + "True": 71 test-flag3072: - percentage: 72 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 28 + "True": 72 test-flag3073: - percentage: 73 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 27 + "True": 73 test-flag3074: - percentage: 74 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 26 + "True": 74 test-flag3075: - percentage: 75 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 25 + "True": 75 test-flag3076: - percentage: 76 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 24 + "True": 76 test-flag3077: - percentage: 77 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 23 + "True": 77 test-flag3078: - percentage: 78 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 22 + "True": 78 test-flag3079: - percentage: 79 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 21 + "True": 79 test-flag3080: - percentage: 80 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 20 + "True": 80 test-flag3081: - percentage: 81 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 19 + "True": 81 test-flag3082: - percentage: 82 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 18 + "True": 82 test-flag3083: - percentage: 83 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 17 + "True": 83 test-flag3084: - percentage: 84 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 16 + "True": 84 test-flag3085: - percentage: 85 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 15 + "True": 85 test-flag3086: - percentage: 86 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 14 + "True": 86 test-flag3087: - percentage: 87 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 13 + "True": 87 test-flag3088: - percentage: 88 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 12 + "True": 88 test-flag3089: - percentage: 89 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 11 + "True": 89 test-flag3090: - percentage: 90 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 10 + "True": 90 test-flag3091: - percentage: 91 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 9 + "True": 91 test-flag3092: - percentage: 92 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 8 + "True": 92 test-flag3093: - percentage: 93 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 7 + "True": 93 test-flag3094: - percentage: 94 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 6 + "True": 94 test-flag3095: - percentage: 95 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 5 + "True": 95 test-flag3096: - percentage: 96 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 4 + "True": 96 test-flag3097: - percentage: 97 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 3 + "True": 97 test-flag3098: - percentage: 98 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 2 + "True": 98 test-flag3099: - percentage: 99 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 1 + "True": 99 test-flag3100: - percentage: 0 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 100 + "True": 0 test-flag3101: - percentage: 1 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 99 + "True": 1 test-flag3102: - percentage: 2 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 98 + "True": 2 test-flag3103: - percentage: 3 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 97 + "True": 3 test-flag3104: - percentage: 4 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 96 + "True": 4 test-flag3105: - percentage: 5 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 95 + "True": 5 test-flag3106: - percentage: 6 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 94 + "True": 6 test-flag3107: - percentage: 7 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 93 + "True": 7 test-flag3108: - percentage: 8 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 92 + "True": 8 test-flag3109: - percentage: 9 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 91 + "True": 9 test-flag3110: - percentage: 10 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 90 + "True": 10 test-flag3111: - percentage: 11 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 89 + "True": 11 test-flag3112: - percentage: 12 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 88 + "True": 12 test-flag3113: - percentage: 13 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 87 + "True": 13 test-flag3114: - percentage: 14 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 86 + "True": 14 test-flag3115: - percentage: 15 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 85 + "True": 15 test-flag3116: - percentage: 16 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 84 + "True": 16 test-flag3117: - percentage: 17 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 83 + "True": 17 test-flag3118: - percentage: 18 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 82 + "True": 18 test-flag3119: - percentage: 19 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 81 + "True": 19 test-flag3120: - percentage: 20 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 80 + "True": 20 test-flag3121: - percentage: 21 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 79 + "True": 21 test-flag3122: - percentage: 22 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 78 + "True": 22 test-flag3123: - percentage: 23 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 77 + "True": 23 test-flag3124: - percentage: 24 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 76 + "True": 24 test-flag3125: - percentage: 25 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 75 + "True": 25 test-flag3126: - percentage: 26 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 74 + "True": 26 test-flag3127: - percentage: 27 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 73 + "True": 27 test-flag3128: - percentage: 28 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 72 + "True": 28 test-flag3129: - percentage: 29 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 71 + "True": 29 test-flag3130: - percentage: 30 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 70 + "True": 30 test-flag3131: - percentage: 31 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 69 + "True": 31 test-flag3132: - percentage: 32 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 68 + "True": 32 test-flag3133: - percentage: 33 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 67 + "True": 33 test-flag3134: - percentage: 34 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 66 + "True": 34 test-flag3135: - percentage: 35 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 65 + "True": 35 test-flag3136: - percentage: 36 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 64 + "True": 36 test-flag3137: - percentage: 37 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 63 + "True": 37 test-flag3138: - percentage: 38 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 62 + "True": 38 test-flag3139: - percentage: 39 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 61 + "True": 39 test-flag3140: - percentage: 40 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 60 + "True": 40 test-flag3141: - percentage: 41 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 59 + "True": 41 test-flag3142: - percentage: 42 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 58 + "True": 42 test-flag3143: - percentage: 43 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 57 + "True": 43 test-flag3144: - percentage: 44 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 56 + "True": 44 test-flag3145: - percentage: 45 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 55 + "True": 45 test-flag3146: - percentage: 46 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 54 + "True": 46 test-flag3147: - percentage: 47 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 53 + "True": 47 test-flag3148: - percentage: 48 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 52 + "True": 48 test-flag3149: - percentage: 49 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 51 + "True": 49 test-flag3150: - percentage: 50 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 50 + "True": 50 test-flag3151: - percentage: 51 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 49 + "True": 51 test-flag3152: - percentage: 52 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 48 + "True": 52 test-flag3153: - percentage: 53 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 47 + "True": 53 test-flag3154: - percentage: 54 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 46 + "True": 54 test-flag3155: - percentage: 55 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 45 + "True": 55 test-flag3156: - percentage: 56 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 44 + "True": 56 test-flag3157: - percentage: 57 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 43 + "True": 57 test-flag3158: - percentage: 58 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 42 + "True": 58 test-flag3159: - percentage: 59 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 41 + "True": 59 test-flag3160: - percentage: 60 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 40 + "True": 60 test-flag3161: - percentage: 61 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 39 + "True": 61 test-flag3162: - percentage: 62 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 38 + "True": 62 test-flag3163: - percentage: 63 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 37 + "True": 63 test-flag3164: - percentage: 64 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 36 + "True": 64 test-flag3165: - percentage: 65 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 35 + "True": 65 test-flag3166: - percentage: 66 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 34 + "True": 66 test-flag3167: - percentage: 67 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 33 + "True": 67 test-flag3168: - percentage: 68 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 32 + "True": 68 test-flag3169: - percentage: 69 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 31 + "True": 69 test-flag3170: - percentage: 70 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 30 + "True": 70 test-flag3171: - percentage: 71 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 29 + "True": 71 test-flag3172: - percentage: 72 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 28 + "True": 72 test-flag3173: - percentage: 73 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 27 + "True": 73 test-flag3174: - percentage: 74 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 26 + "True": 74 test-flag3175: - percentage: 75 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 25 + "True": 75 test-flag3176: - percentage: 76 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 24 + "True": 76 test-flag3177: - percentage: 77 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 23 + "True": 77 test-flag3178: - percentage: 78 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 22 + "True": 78 test-flag3179: - percentage: 79 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 21 + "True": 79 test-flag3180: - percentage: 80 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 20 + "True": 80 test-flag3181: - percentage: 81 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 19 + "True": 81 test-flag3182: - percentage: 82 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 18 + "True": 82 test-flag3183: - percentage: 83 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 17 + "True": 83 test-flag3184: - percentage: 84 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 16 + "True": 84 test-flag3185: - percentage: 85 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 15 + "True": 85 test-flag3186: - percentage: 86 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 14 + "True": 86 test-flag3187: - percentage: 87 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 13 + "True": 87 test-flag3188: - percentage: 88 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 12 + "True": 88 test-flag3189: - percentage: 89 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 11 + "True": 89 test-flag3190: - percentage: 90 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 10 + "True": 90 test-flag3191: - percentage: 91 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 9 + "True": 91 test-flag3192: - percentage: 92 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 8 + "True": 92 test-flag3193: - percentage: 93 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 7 + "True": 93 test-flag3194: - percentage: 94 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 6 + "True": 94 test-flag3195: - percentage: 95 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 5 + "True": 95 test-flag3196: - percentage: 96 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 4 + "True": 96 test-flag3197: - percentage: 97 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 3 + "True": 97 test-flag3198: - percentage: 98 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 2 + "True": 98 test-flag3199: - percentage: 99 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 1 + "True": 99 test-flag3200: - percentage: 0 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 100 + "True": 0 test-flag3201: - percentage: 1 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 99 + "True": 1 test-flag3202: - percentage: 2 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 98 + "True": 2 test-flag3203: - percentage: 3 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 97 + "True": 3 test-flag3204: - percentage: 4 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 96 + "True": 4 test-flag3205: - percentage: 5 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 95 + "True": 5 test-flag3206: - percentage: 6 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 94 + "True": 6 test-flag3207: - percentage: 7 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 93 + "True": 7 test-flag3208: - percentage: 8 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 92 + "True": 8 test-flag3209: - percentage: 9 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 91 + "True": 9 test-flag3210: - percentage: 10 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 90 + "True": 10 test-flag3211: - percentage: 11 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 89 + "True": 11 test-flag3212: - percentage: 12 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 88 + "True": 12 test-flag3213: - percentage: 13 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 87 + "True": 13 test-flag3214: - percentage: 14 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 86 + "True": 14 test-flag3215: - percentage: 15 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 85 + "True": 15 test-flag3216: - percentage: 16 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 84 + "True": 16 test-flag3217: - percentage: 17 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 83 + "True": 17 test-flag3218: - percentage: 18 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 82 + "True": 18 test-flag3219: - percentage: 19 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 81 + "True": 19 test-flag3220: - percentage: 20 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 80 + "True": 20 test-flag3221: - percentage: 21 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 79 + "True": 21 test-flag3222: - percentage: 22 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 78 + "True": 22 test-flag3223: - percentage: 23 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 77 + "True": 23 test-flag3224: - percentage: 24 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 76 + "True": 24 test-flag3225: - percentage: 25 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 75 + "True": 25 test-flag3226: - percentage: 26 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 74 + "True": 26 test-flag3227: - percentage: 27 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 73 + "True": 27 test-flag3228: - percentage: 28 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 72 + "True": 28 test-flag3229: - percentage: 29 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 71 + "True": 29 test-flag3230: - percentage: 30 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 70 + "True": 30 test-flag3231: - percentage: 31 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 69 + "True": 31 test-flag3232: - percentage: 32 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 68 + "True": 32 test-flag3233: - percentage: 33 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 67 + "True": 33 test-flag3234: - percentage: 34 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 66 + "True": 34 test-flag3235: - percentage: 35 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 65 + "True": 35 test-flag3236: - percentage: 36 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 64 + "True": 36 test-flag3237: - percentage: 37 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 63 + "True": 37 test-flag3238: - percentage: 38 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 62 + "True": 38 test-flag3239: - percentage: 39 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 61 + "True": 39 test-flag3240: - percentage: 40 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 60 + "True": 40 test-flag3241: - percentage: 41 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 59 + "True": 41 test-flag3242: - percentage: 42 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 58 + "True": 42 test-flag3243: - percentage: 43 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 57 + "True": 43 test-flag3244: - percentage: 44 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 56 + "True": 44 test-flag3245: - percentage: 45 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 55 + "True": 45 test-flag3246: - percentage: 46 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 54 + "True": 46 test-flag3247: - percentage: 47 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 53 + "True": 47 test-flag3248: - percentage: 48 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 52 + "True": 48 test-flag3249: - percentage: 49 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 51 + "True": 49 test-flag3250: - percentage: 50 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 50 + "True": 50 test-flag3251: - percentage: 51 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 49 + "True": 51 test-flag3252: - percentage: 52 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 48 + "True": 52 test-flag3253: - percentage: 53 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 47 + "True": 53 test-flag3254: - percentage: 54 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 46 + "True": 54 test-flag3255: - percentage: 55 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 45 + "True": 55 test-flag3256: - percentage: 56 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 44 + "True": 56 test-flag3257: - percentage: 57 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 43 + "True": 57 test-flag3258: - percentage: 58 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 42 + "True": 58 test-flag3259: - percentage: 59 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 41 + "True": 59 test-flag3260: - percentage: 60 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 40 + "True": 60 test-flag3261: - percentage: 61 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 39 + "True": 61 test-flag3262: - percentage: 62 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 38 + "True": 62 test-flag3263: - percentage: 63 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 37 + "True": 63 test-flag3264: - percentage: 64 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 36 + "True": 64 test-flag3265: - percentage: 65 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 35 + "True": 65 test-flag3266: - percentage: 66 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 34 + "True": 66 test-flag3267: - percentage: 67 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 33 + "True": 67 test-flag3268: - percentage: 68 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 32 + "True": 68 test-flag3269: - percentage: 69 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 31 + "True": 69 test-flag3270: - percentage: 70 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 30 + "True": 70 test-flag3271: - percentage: 71 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 29 + "True": 71 test-flag3272: - percentage: 72 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 28 + "True": 72 test-flag3273: - percentage: 73 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 27 + "True": 73 test-flag3274: - percentage: 74 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 26 + "True": 74 test-flag3275: - percentage: 75 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 25 + "True": 75 test-flag3276: - percentage: 76 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 24 + "True": 76 test-flag3277: - percentage: 77 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 23 + "True": 77 test-flag3278: - percentage: 78 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 22 + "True": 78 test-flag3279: - percentage: 79 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 21 + "True": 79 test-flag3280: - percentage: 80 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 20 + "True": 80 test-flag3281: - percentage: 81 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 19 + "True": 81 test-flag3282: - percentage: 82 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 18 + "True": 82 test-flag3283: - percentage: 83 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 17 + "True": 83 test-flag3284: - percentage: 84 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 16 + "True": 84 test-flag3285: - percentage: 85 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 15 + "True": 85 test-flag3286: - percentage: 86 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 14 + "True": 86 test-flag3287: - percentage: 87 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 13 + "True": 87 test-flag3288: - percentage: 88 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 12 + "True": 88 test-flag3289: - percentage: 89 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 11 + "True": 89 test-flag3290: - percentage: 90 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 10 + "True": 90 test-flag3291: - percentage: 91 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 9 + "True": 91 test-flag3292: - percentage: 92 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 8 + "True": 92 test-flag3293: - percentage: 93 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 7 + "True": 93 test-flag3294: - percentage: 94 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 6 + "True": 94 test-flag3295: - percentage: 95 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 5 + "True": 95 test-flag3296: - percentage: 96 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 4 + "True": 96 test-flag3297: - percentage: 97 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 3 + "True": 97 test-flag3298: - percentage: 98 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 2 + "True": 98 test-flag3299: - percentage: 99 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 1 + "True": 99 test-flag3300: - percentage: 0 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 100 + "True": 0 test-flag3301: - percentage: 1 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 99 + "True": 1 test-flag3302: - percentage: 2 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 98 + "True": 2 test-flag3303: - percentage: 3 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 97 + "True": 3 test-flag3304: - percentage: 4 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 96 + "True": 4 test-flag3305: - percentage: 5 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 95 + "True": 5 test-flag3306: - percentage: 6 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 94 + "True": 6 test-flag3307: - percentage: 7 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 93 + "True": 7 test-flag3308: - percentage: 8 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 92 + "True": 8 test-flag3309: - percentage: 9 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 91 + "True": 9 test-flag3310: - percentage: 10 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 90 + "True": 10 test-flag3311: - percentage: 11 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 89 + "True": 11 test-flag3312: - percentage: 12 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 88 + "True": 12 test-flag3313: - percentage: 13 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 87 + "True": 13 test-flag3314: - percentage: 14 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 86 + "True": 14 test-flag3315: - percentage: 15 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 85 + "True": 15 test-flag3316: - percentage: 16 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 84 + "True": 16 test-flag3317: - percentage: 17 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 83 + "True": 17 test-flag3318: - percentage: 18 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 82 + "True": 18 test-flag3319: - percentage: 19 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 81 + "True": 19 test-flag3320: - percentage: 20 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 80 + "True": 20 test-flag3321: - percentage: 21 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 79 + "True": 21 test-flag3322: - percentage: 22 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 78 + "True": 22 test-flag3323: - percentage: 23 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 77 + "True": 23 test-flag3324: - percentage: 24 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 76 + "True": 24 test-flag3325: - percentage: 25 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 75 + "True": 25 test-flag3326: - percentage: 26 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 74 + "True": 26 test-flag3327: - percentage: 27 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 73 + "True": 27 test-flag3328: - percentage: 28 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 72 + "True": 28 test-flag3329: - percentage: 29 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 71 + "True": 29 test-flag3330: - percentage: 30 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 70 + "True": 30 test-flag3331: - percentage: 31 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 69 + "True": 31 test-flag3332: - percentage: 32 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 68 + "True": 32 test-flag3333: - percentage: 33 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 67 + "True": 33 test-flag3334: - percentage: 34 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 66 + "True": 34 test-flag3335: - percentage: 35 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 65 + "True": 35 test-flag3336: - percentage: 36 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 64 + "True": 36 test-flag3337: - percentage: 37 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 63 + "True": 37 test-flag3338: - percentage: 38 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 62 + "True": 38 test-flag3339: - percentage: 39 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 61 + "True": 39 test-flag3340: - percentage: 40 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 60 + "True": 40 test-flag3341: - percentage: 41 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 59 + "True": 41 test-flag3342: - percentage: 42 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 58 + "True": 42 test-flag3343: - percentage: 43 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 57 + "True": 43 test-flag3344: - percentage: 44 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 56 + "True": 44 test-flag3345: - percentage: 45 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 55 + "True": 45 test-flag3346: - percentage: 46 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 54 + "True": 46 test-flag3347: - percentage: 47 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 53 + "True": 47 test-flag3348: - percentage: 48 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 52 + "True": 48 test-flag3349: - percentage: 49 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 51 + "True": 49 test-flag3350: - percentage: 50 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 50 + "True": 50 test-flag3351: - percentage: 51 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 49 + "True": 51 test-flag3352: - percentage: 52 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 48 + "True": 52 test-flag3353: - percentage: 53 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 47 + "True": 53 test-flag3354: - percentage: 54 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 46 + "True": 54 test-flag3355: - percentage: 55 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 45 + "True": 55 test-flag3356: - percentage: 56 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 44 + "True": 56 test-flag3357: - percentage: 57 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 43 + "True": 57 test-flag3358: - percentage: 58 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 42 + "True": 58 test-flag3359: - percentage: 59 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 41 + "True": 59 test-flag3360: - percentage: 60 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 40 + "True": 60 test-flag3361: - percentage: 61 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 39 + "True": 61 test-flag3362: - percentage: 62 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 38 + "True": 62 test-flag3363: - percentage: 63 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 37 + "True": 63 test-flag3364: - percentage: 64 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 36 + "True": 64 test-flag3365: - percentage: 65 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 35 + "True": 65 test-flag3366: - percentage: 66 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 34 + "True": 66 test-flag3367: - percentage: 67 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 33 + "True": 67 test-flag3368: - percentage: 68 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 32 + "True": 68 test-flag3369: - percentage: 69 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 31 + "True": 69 test-flag3370: - percentage: 70 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 30 + "True": 70 test-flag3371: - percentage: 71 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 29 + "True": 71 test-flag3372: - percentage: 72 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 28 + "True": 72 test-flag3373: - percentage: 73 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 27 + "True": 73 test-flag3374: - percentage: 74 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 26 + "True": 74 test-flag3375: - percentage: 75 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 25 + "True": 75 test-flag3376: - percentage: 76 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 24 + "True": 76 test-flag3377: - percentage: 77 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 23 + "True": 77 test-flag3378: - percentage: 78 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 22 + "True": 78 test-flag3379: - percentage: 79 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 21 + "True": 79 test-flag3380: - percentage: 80 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 20 + "True": 80 test-flag3381: - percentage: 81 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 19 + "True": 81 test-flag3382: - percentage: 82 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 18 + "True": 82 test-flag3383: - percentage: 83 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 17 + "True": 83 test-flag3384: - percentage: 84 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 16 + "True": 84 test-flag3385: - percentage: 85 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 15 + "True": 85 test-flag3386: - percentage: 86 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 14 + "True": 86 test-flag3387: - percentage: 87 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 13 + "True": 87 test-flag3388: - percentage: 88 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 12 + "True": 88 test-flag3389: - percentage: 89 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 11 + "True": 89 test-flag3390: - percentage: 90 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 10 + "True": 90 test-flag3391: - percentage: 91 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 9 + "True": 91 test-flag3392: - percentage: 92 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 8 + "True": 92 test-flag3393: - percentage: 93 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 7 + "True": 93 test-flag3394: - percentage: 94 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 6 + "True": 94 test-flag3395: - percentage: 95 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 5 + "True": 95 test-flag3396: - percentage: 96 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 4 + "True": 96 test-flag3397: - percentage: 97 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 3 + "True": 97 test-flag3398: - percentage: 98 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 2 + "True": 98 test-flag3399: - percentage: 99 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 1 + "True": 99 test-flag3400: - percentage: 0 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 100 + "True": 0 test-flag3401: - percentage: 1 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 99 + "True": 1 test-flag3402: - percentage: 2 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 98 + "True": 2 test-flag3403: - percentage: 3 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 97 + "True": 3 test-flag3404: - percentage: 4 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 96 + "True": 4 test-flag3405: - percentage: 5 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 95 + "True": 5 test-flag3406: - percentage: 6 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 94 + "True": 6 test-flag3407: - percentage: 7 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 93 + "True": 7 test-flag3408: - percentage: 8 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 92 + "True": 8 test-flag3409: - percentage: 9 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 91 + "True": 9 test-flag3410: - percentage: 10 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 90 + "True": 10 test-flag3411: - percentage: 11 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 89 + "True": 11 test-flag3412: - percentage: 12 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 88 + "True": 12 test-flag3413: - percentage: 13 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 87 + "True": 13 test-flag3414: - percentage: 14 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 86 + "True": 14 test-flag3415: - percentage: 15 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 85 + "True": 15 test-flag3416: - percentage: 16 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 84 + "True": 16 test-flag3417: - percentage: 17 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 83 + "True": 17 test-flag3418: - percentage: 18 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 82 + "True": 18 test-flag3419: - percentage: 19 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 81 + "True": 19 test-flag3420: - percentage: 20 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 80 + "True": 20 test-flag3421: - percentage: 21 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 79 + "True": 21 test-flag3422: - percentage: 22 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 78 + "True": 22 test-flag3423: - percentage: 23 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 77 + "True": 23 test-flag3424: - percentage: 24 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 76 + "True": 24 test-flag3425: - percentage: 25 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 75 + "True": 25 test-flag3426: - percentage: 26 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 74 + "True": 26 test-flag3427: - percentage: 27 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 73 + "True": 27 test-flag3428: - percentage: 28 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 72 + "True": 28 test-flag3429: - percentage: 29 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 71 + "True": 29 test-flag3430: - percentage: 30 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 70 + "True": 30 test-flag3431: - percentage: 31 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 69 + "True": 31 test-flag3432: - percentage: 32 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 68 + "True": 32 test-flag3433: - percentage: 33 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 67 + "True": 33 test-flag3434: - percentage: 34 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 66 + "True": 34 test-flag3435: - percentage: 35 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 65 + "True": 35 test-flag3436: - percentage: 36 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 64 + "True": 36 test-flag3437: - percentage: 37 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 63 + "True": 37 test-flag3438: - percentage: 38 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 62 + "True": 38 test-flag3439: - percentage: 39 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 61 + "True": 39 test-flag3440: - percentage: 40 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 60 + "True": 40 test-flag3441: - percentage: 41 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 59 + "True": 41 test-flag3442: - percentage: 42 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 58 + "True": 42 test-flag3443: - percentage: 43 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 57 + "True": 43 test-flag3444: - percentage: 44 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 56 + "True": 44 test-flag3445: - percentage: 45 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 55 + "True": 45 test-flag3446: - percentage: 46 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 54 + "True": 46 test-flag3447: - percentage: 47 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 53 + "True": 47 test-flag3448: - percentage: 48 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 52 + "True": 48 test-flag3449: - percentage: 49 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 51 + "True": 49 test-flag3450: - percentage: 50 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 50 + "True": 50 test-flag3451: - percentage: 51 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 49 + "True": 51 test-flag3452: - percentage: 52 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 48 + "True": 52 test-flag3453: - percentage: 53 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 47 + "True": 53 test-flag3454: - percentage: 54 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 46 + "True": 54 test-flag3455: - percentage: 55 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 45 + "True": 55 test-flag3456: - percentage: 56 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 44 + "True": 56 test-flag3457: - percentage: 57 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 43 + "True": 57 test-flag3458: - percentage: 58 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 42 + "True": 58 test-flag3459: - percentage: 59 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 41 + "True": 59 test-flag3460: - percentage: 60 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 40 + "True": 60 test-flag3461: - percentage: 61 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 39 + "True": 61 test-flag3462: - percentage: 62 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 38 + "True": 62 test-flag3463: - percentage: 63 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 37 + "True": 63 test-flag3464: - percentage: 64 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 36 + "True": 64 test-flag3465: - percentage: 65 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 35 + "True": 65 test-flag3466: - percentage: 66 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 34 + "True": 66 test-flag3467: - percentage: 67 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 33 + "True": 67 test-flag3468: - percentage: 68 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 32 + "True": 68 test-flag3469: - percentage: 69 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 31 + "True": 69 test-flag3470: - percentage: 70 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 30 + "True": 70 test-flag3471: - percentage: 71 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 29 + "True": 71 test-flag3472: - percentage: 72 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 28 + "True": 72 test-flag3473: - percentage: 73 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 27 + "True": 73 test-flag3474: - percentage: 74 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 26 + "True": 74 test-flag3475: - percentage: 75 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 25 + "True": 75 test-flag3476: - percentage: 76 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 24 + "True": 76 test-flag3477: - percentage: 77 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 23 + "True": 77 test-flag3478: - percentage: 78 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 22 + "True": 78 test-flag3479: - percentage: 79 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 21 + "True": 79 test-flag3480: - percentage: 80 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 20 + "True": 80 test-flag3481: - percentage: 81 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 19 + "True": 81 test-flag3482: - percentage: 82 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 18 + "True": 82 test-flag3483: - percentage: 83 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 17 + "True": 83 test-flag3484: - percentage: 84 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 16 + "True": 84 test-flag3485: - percentage: 85 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 15 + "True": 85 test-flag3486: - percentage: 86 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 14 + "True": 86 test-flag3487: - percentage: 87 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 13 + "True": 87 test-flag3488: - percentage: 88 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 12 + "True": 88 test-flag3489: - percentage: 89 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 11 + "True": 89 test-flag3490: - percentage: 90 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 10 + "True": 90 test-flag3491: - percentage: 91 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 9 + "True": 91 test-flag3492: - percentage: 92 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 8 + "True": 92 test-flag3493: - percentage: 93 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 7 + "True": 93 test-flag3494: - percentage: 94 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 6 + "True": 94 test-flag3495: - percentage: 95 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 5 + "True": 95 test-flag3496: - percentage: 96 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 4 + "True": 96 test-flag3497: - percentage: 97 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 3 + "True": 97 test-flag3498: - percentage: 98 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 2 + "True": 98 test-flag3499: - percentage: 99 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 1 + "True": 99 test-flag3500: - percentage: 0 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 100 + "True": 0 test-flag3501: - percentage: 1 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 99 + "True": 1 test-flag3502: - percentage: 2 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 98 + "True": 2 test-flag3503: - percentage: 3 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 97 + "True": 3 test-flag3504: - percentage: 4 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 96 + "True": 4 test-flag3505: - percentage: 5 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 95 + "True": 5 test-flag3506: - percentage: 6 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 94 + "True": 6 test-flag3507: - percentage: 7 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 93 + "True": 7 test-flag3508: - percentage: 8 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 92 + "True": 8 test-flag3509: - percentage: 9 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 91 + "True": 9 test-flag3510: - percentage: 10 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 90 + "True": 10 test-flag3511: - percentage: 11 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 89 + "True": 11 test-flag3512: - percentage: 12 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 88 + "True": 12 test-flag3513: - percentage: 13 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 87 + "True": 13 test-flag3514: - percentage: 14 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 86 + "True": 14 test-flag3515: - percentage: 15 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 85 + "True": 15 test-flag3516: - percentage: 16 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 84 + "True": 16 test-flag3517: - percentage: 17 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 83 + "True": 17 test-flag3518: - percentage: 18 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 82 + "True": 18 test-flag3519: - percentage: 19 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 81 + "True": 19 test-flag3520: - percentage: 20 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 80 + "True": 20 test-flag3521: - percentage: 21 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 79 + "True": 21 test-flag3522: - percentage: 22 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 78 + "True": 22 test-flag3523: - percentage: 23 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 77 + "True": 23 test-flag3524: - percentage: 24 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 76 + "True": 24 test-flag3525: - percentage: 25 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 75 + "True": 25 test-flag3526: - percentage: 26 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 74 + "True": 26 test-flag3527: - percentage: 27 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 73 + "True": 27 test-flag3528: - percentage: 28 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 72 + "True": 28 test-flag3529: - percentage: 29 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 71 + "True": 29 test-flag3530: - percentage: 30 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 70 + "True": 30 test-flag3531: - percentage: 31 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 69 + "True": 31 test-flag3532: - percentage: 32 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 68 + "True": 32 test-flag3533: - percentage: 33 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 67 + "True": 33 test-flag3534: - percentage: 34 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 66 + "True": 34 test-flag3535: - percentage: 35 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 65 + "True": 35 test-flag3536: - percentage: 36 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 64 + "True": 36 test-flag3537: - percentage: 37 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 63 + "True": 37 test-flag3538: - percentage: 38 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 62 + "True": 38 test-flag3539: - percentage: 39 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 61 + "True": 39 test-flag3540: - percentage: 40 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 60 + "True": 40 test-flag3541: - percentage: 41 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 59 + "True": 41 test-flag3542: - percentage: 42 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 58 + "True": 42 test-flag3543: - percentage: 43 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 57 + "True": 43 test-flag3544: - percentage: 44 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 56 + "True": 44 test-flag3545: - percentage: 45 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 55 + "True": 45 test-flag3546: - percentage: 46 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 54 + "True": 46 test-flag3547: - percentage: 47 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 53 + "True": 47 test-flag3548: - percentage: 48 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 52 + "True": 48 test-flag3549: - percentage: 49 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 51 + "True": 49 test-flag3550: - percentage: 50 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 50 + "True": 50 test-flag3551: - percentage: 51 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 49 + "True": 51 test-flag3552: - percentage: 52 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 48 + "True": 52 test-flag3553: - percentage: 53 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 47 + "True": 53 test-flag3554: - percentage: 54 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 46 + "True": 54 test-flag3555: - percentage: 55 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 45 + "True": 55 test-flag3556: - percentage: 56 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 44 + "True": 56 test-flag3557: - percentage: 57 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 43 + "True": 57 test-flag3558: - percentage: 58 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 42 + "True": 58 test-flag3559: - percentage: 59 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 41 + "True": 59 test-flag3560: - percentage: 60 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 40 + "True": 60 test-flag3561: - percentage: 61 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 39 + "True": 61 test-flag3562: - percentage: 62 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 38 + "True": 62 test-flag3563: - percentage: 63 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 37 + "True": 63 test-flag3564: - percentage: 64 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 36 + "True": 64 test-flag3565: - percentage: 65 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 35 + "True": 65 test-flag3566: - percentage: 66 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 34 + "True": 66 test-flag3567: - percentage: 67 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 33 + "True": 67 test-flag3568: - percentage: 68 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 32 + "True": 68 test-flag3569: - percentage: 69 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 31 + "True": 69 test-flag3570: - percentage: 70 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 30 + "True": 70 test-flag3571: - percentage: 71 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 29 + "True": 71 test-flag3572: - percentage: 72 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 28 + "True": 72 test-flag3573: - percentage: 73 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 27 + "True": 73 test-flag3574: - percentage: 74 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 26 + "True": 74 test-flag3575: - percentage: 75 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 25 + "True": 75 test-flag3576: - percentage: 76 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 24 + "True": 76 test-flag3577: - percentage: 77 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 23 + "True": 77 test-flag3578: - percentage: 78 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 22 + "True": 78 test-flag3579: - percentage: 79 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 21 + "True": 79 test-flag3580: - percentage: 80 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 20 + "True": 80 test-flag3581: - percentage: 81 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 19 + "True": 81 test-flag3582: - percentage: 82 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 18 + "True": 82 test-flag3583: - percentage: 83 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 17 + "True": 83 test-flag3584: - percentage: 84 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 16 + "True": 84 test-flag3585: - percentage: 85 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 15 + "True": 85 test-flag3586: - percentage: 86 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 14 + "True": 86 test-flag3587: - percentage: 87 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 13 + "True": 87 test-flag3588: - percentage: 88 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 12 + "True": 88 test-flag3589: - percentage: 89 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 11 + "True": 89 test-flag3590: - percentage: 90 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 10 + "True": 90 test-flag3591: - percentage: 91 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 9 + "True": 91 test-flag3592: - percentage: 92 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 8 + "True": 92 test-flag3593: - percentage: 93 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 7 + "True": 93 test-flag3594: - percentage: 94 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 6 + "True": 94 test-flag3595: - percentage: 95 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 5 + "True": 95 test-flag3596: - percentage: 96 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 4 + "True": 96 test-flag3597: - percentage: 97 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 3 + "True": 97 test-flag3598: - percentage: 98 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 2 + "True": 98 test-flag3599: - percentage: 99 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 1 + "True": 99 test-flag3600: - percentage: 0 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 100 + "True": 0 test-flag3601: - percentage: 1 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 99 + "True": 1 test-flag3602: - percentage: 2 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 98 + "True": 2 test-flag3603: - percentage: 3 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 97 + "True": 3 test-flag3604: - percentage: 4 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 96 + "True": 4 test-flag3605: - percentage: 5 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 95 + "True": 5 test-flag3606: - percentage: 6 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 94 + "True": 6 test-flag3607: - percentage: 7 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 93 + "True": 7 test-flag3608: - percentage: 8 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 92 + "True": 8 test-flag3609: - percentage: 9 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 91 + "True": 9 test-flag3610: - percentage: 10 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 90 + "True": 10 test-flag3611: - percentage: 11 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 89 + "True": 11 test-flag3612: - percentage: 12 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 88 + "True": 12 test-flag3613: - percentage: 13 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 87 + "True": 13 test-flag3614: - percentage: 14 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 86 + "True": 14 test-flag3615: - percentage: 15 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 85 + "True": 15 test-flag3616: - percentage: 16 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 84 + "True": 16 test-flag3617: - percentage: 17 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 83 + "True": 17 test-flag3618: - percentage: 18 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 82 + "True": 18 test-flag3619: - percentage: 19 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 81 + "True": 19 test-flag3620: - percentage: 20 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 80 + "True": 20 test-flag3621: - percentage: 21 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 79 + "True": 21 test-flag3622: - percentage: 22 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 78 + "True": 22 test-flag3623: - percentage: 23 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 77 + "True": 23 test-flag3624: - percentage: 24 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 76 + "True": 24 test-flag3625: - percentage: 25 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 75 + "True": 25 test-flag3626: - percentage: 26 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 74 + "True": 26 test-flag3627: - percentage: 27 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 73 + "True": 27 test-flag3628: - percentage: 28 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 72 + "True": 28 test-flag3629: - percentage: 29 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 71 + "True": 29 test-flag3630: - percentage: 30 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 70 + "True": 30 test-flag3631: - percentage: 31 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 69 + "True": 31 test-flag3632: - percentage: 32 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 68 + "True": 32 test-flag3633: - percentage: 33 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 67 + "True": 33 test-flag3634: - percentage: 34 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 66 + "True": 34 test-flag3635: - percentage: 35 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 65 + "True": 35 test-flag3636: - percentage: 36 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 64 + "True": 36 test-flag3637: - percentage: 37 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 63 + "True": 37 test-flag3638: - percentage: 38 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 62 + "True": 38 test-flag3639: - percentage: 39 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 61 + "True": 39 test-flag3640: - percentage: 40 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 60 + "True": 40 test-flag3641: - percentage: 41 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 59 + "True": 41 test-flag3642: - percentage: 42 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 58 + "True": 42 test-flag3643: - percentage: 43 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 57 + "True": 43 test-flag3644: - percentage: 44 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 56 + "True": 44 test-flag3645: - percentage: 45 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 55 + "True": 45 test-flag3646: - percentage: 46 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 54 + "True": 46 test-flag3647: - percentage: 47 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 53 + "True": 47 test-flag3648: - percentage: 48 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 52 + "True": 48 test-flag3649: - percentage: 49 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 51 + "True": 49 test-flag3650: - percentage: 50 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 50 + "True": 50 test-flag3651: - percentage: 51 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 49 + "True": 51 test-flag3652: - percentage: 52 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 48 + "True": 52 test-flag3653: - percentage: 53 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 47 + "True": 53 test-flag3654: - percentage: 54 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 46 + "True": 54 test-flag3655: - percentage: 55 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 45 + "True": 55 test-flag3656: - percentage: 56 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 44 + "True": 56 test-flag3657: - percentage: 57 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 43 + "True": 57 test-flag3658: - percentage: 58 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 42 + "True": 58 test-flag3659: - percentage: 59 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 41 + "True": 59 test-flag3660: - percentage: 60 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 40 + "True": 60 test-flag3661: - percentage: 61 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 39 + "True": 61 test-flag3662: - percentage: 62 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 38 + "True": 62 test-flag3663: - percentage: 63 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 37 + "True": 63 test-flag3664: - percentage: 64 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 36 + "True": 64 test-flag3665: - percentage: 65 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 35 + "True": 65 test-flag3666: - percentage: 66 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 34 + "True": 66 test-flag3667: - percentage: 67 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 33 + "True": 67 test-flag3668: - percentage: 68 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 32 + "True": 68 test-flag3669: - percentage: 69 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 31 + "True": 69 test-flag3670: - percentage: 70 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 30 + "True": 70 test-flag3671: - percentage: 71 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 29 + "True": 71 test-flag3672: - percentage: 72 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 28 + "True": 72 test-flag3673: - percentage: 73 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 27 + "True": 73 test-flag3674: - percentage: 74 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 26 + "True": 74 test-flag3675: - percentage: 75 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 25 + "True": 75 test-flag3676: - percentage: 76 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 24 + "True": 76 test-flag3677: - percentage: 77 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 23 + "True": 77 test-flag3678: - percentage: 78 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 22 + "True": 78 test-flag3679: - percentage: 79 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 21 + "True": 79 test-flag3680: - percentage: 80 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 20 + "True": 80 test-flag3681: - percentage: 81 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 19 + "True": 81 test-flag3682: - percentage: 82 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 18 + "True": 82 test-flag3683: - percentage: 83 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 17 + "True": 83 test-flag3684: - percentage: 84 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 16 + "True": 84 test-flag3685: - percentage: 85 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 15 + "True": 85 test-flag3686: - percentage: 86 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 14 + "True": 86 test-flag3687: - percentage: 87 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 13 + "True": 87 test-flag3688: - percentage: 88 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 12 + "True": 88 test-flag3689: - percentage: 89 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 11 + "True": 89 test-flag3690: - percentage: 90 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 10 + "True": 90 test-flag3691: - percentage: 91 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 9 + "True": 91 test-flag3692: - percentage: 92 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 8 + "True": 92 test-flag3693: - percentage: 93 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 7 + "True": 93 test-flag3694: - percentage: 94 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 6 + "True": 94 test-flag3695: - percentage: 95 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 5 + "True": 95 test-flag3696: - percentage: 96 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 4 + "True": 96 test-flag3697: - percentage: 97 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 3 + "True": 97 test-flag3698: - percentage: 98 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 2 + "True": 98 test-flag3699: - percentage: 99 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 1 + "True": 99 test-flag3700: - percentage: 0 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 100 + "True": 0 test-flag3701: - percentage: 1 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 99 + "True": 1 test-flag3702: - percentage: 2 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 98 + "True": 2 test-flag3703: - percentage: 3 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 97 + "True": 3 test-flag3704: - percentage: 4 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 96 + "True": 4 test-flag3705: - percentage: 5 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 95 + "True": 5 test-flag3706: - percentage: 6 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 94 + "True": 6 test-flag3707: - percentage: 7 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 93 + "True": 7 test-flag3708: - percentage: 8 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 92 + "True": 8 test-flag3709: - percentage: 9 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 91 + "True": 9 test-flag3710: - percentage: 10 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 90 + "True": 10 test-flag3711: - percentage: 11 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 89 + "True": 11 test-flag3712: - percentage: 12 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 88 + "True": 12 test-flag3713: - percentage: 13 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 87 + "True": 13 test-flag3714: - percentage: 14 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 86 + "True": 14 test-flag3715: - percentage: 15 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 85 + "True": 15 test-flag3716: - percentage: 16 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 84 + "True": 16 test-flag3717: - percentage: 17 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 83 + "True": 17 test-flag3718: - percentage: 18 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 82 + "True": 18 test-flag3719: - percentage: 19 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 81 + "True": 19 test-flag3720: - percentage: 20 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 80 + "True": 20 test-flag3721: - percentage: 21 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 79 + "True": 21 test-flag3722: - percentage: 22 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 78 + "True": 22 test-flag3723: - percentage: 23 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 77 + "True": 23 test-flag3724: - percentage: 24 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 76 + "True": 24 test-flag3725: - percentage: 25 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 75 + "True": 25 test-flag3726: - percentage: 26 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 74 + "True": 26 test-flag3727: - percentage: 27 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 73 + "True": 27 test-flag3728: - percentage: 28 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 72 + "True": 28 test-flag3729: - percentage: 29 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 71 + "True": 29 test-flag3730: - percentage: 30 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 70 + "True": 30 test-flag3731: - percentage: 31 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 69 + "True": 31 test-flag3732: - percentage: 32 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 68 + "True": 32 test-flag3733: - percentage: 33 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 67 + "True": 33 test-flag3734: - percentage: 34 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 66 + "True": 34 test-flag3735: - percentage: 35 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 65 + "True": 35 test-flag3736: - percentage: 36 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 64 + "True": 36 test-flag3737: - percentage: 37 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 63 + "True": 37 test-flag3738: - percentage: 38 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 62 + "True": 38 test-flag3739: - percentage: 39 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 61 + "True": 39 test-flag3740: - percentage: 40 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 60 + "True": 40 test-flag3741: - percentage: 41 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 59 + "True": 41 test-flag3742: - percentage: 42 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 58 + "True": 42 test-flag3743: - percentage: 43 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 57 + "True": 43 test-flag3744: - percentage: 44 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 56 + "True": 44 test-flag3745: - percentage: 45 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 55 + "True": 45 test-flag3746: - percentage: 46 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 54 + "True": 46 test-flag3747: - percentage: 47 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 53 + "True": 47 test-flag3748: - percentage: 48 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 52 + "True": 48 test-flag3749: - percentage: 49 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 51 + "True": 49 test-flag3750: - percentage: 50 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 50 + "True": 50 test-flag3751: - percentage: 51 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 49 + "True": 51 test-flag3752: - percentage: 52 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 48 + "True": 52 test-flag3753: - percentage: 53 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 47 + "True": 53 test-flag3754: - percentage: 54 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 46 + "True": 54 test-flag3755: - percentage: 55 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 45 + "True": 55 test-flag3756: - percentage: 56 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 44 + "True": 56 test-flag3757: - percentage: 57 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 43 + "True": 57 test-flag3758: - percentage: 58 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 42 + "True": 58 test-flag3759: - percentage: 59 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 41 + "True": 59 test-flag3760: - percentage: 60 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 40 + "True": 60 test-flag3761: - percentage: 61 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 39 + "True": 61 test-flag3762: - percentage: 62 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 38 + "True": 62 test-flag3763: - percentage: 63 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 37 + "True": 63 test-flag3764: - percentage: 64 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 36 + "True": 64 test-flag3765: - percentage: 65 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 35 + "True": 65 test-flag3766: - percentage: 66 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 34 + "True": 66 test-flag3767: - percentage: 67 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 33 + "True": 67 test-flag3768: - percentage: 68 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 32 + "True": 68 test-flag3769: - percentage: 69 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 31 + "True": 69 test-flag3770: - percentage: 70 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 30 + "True": 70 test-flag3771: - percentage: 71 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 29 + "True": 71 test-flag3772: - percentage: 72 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 28 + "True": 72 test-flag3773: - percentage: 73 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 27 + "True": 73 test-flag3774: - percentage: 74 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 26 + "True": 74 test-flag3775: - percentage: 75 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 25 + "True": 75 test-flag3776: - percentage: 76 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 24 + "True": 76 test-flag3777: - percentage: 77 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 23 + "True": 77 test-flag3778: - percentage: 78 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 22 + "True": 78 test-flag3779: - percentage: 79 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 21 + "True": 79 test-flag3780: - percentage: 80 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 20 + "True": 80 test-flag3781: - percentage: 81 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 19 + "True": 81 test-flag3782: - percentage: 82 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 18 + "True": 82 test-flag3783: - percentage: 83 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 17 + "True": 83 test-flag3784: - percentage: 84 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 16 + "True": 84 test-flag3785: - percentage: 85 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 15 + "True": 85 test-flag3786: - percentage: 86 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 14 + "True": 86 test-flag3787: - percentage: 87 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 13 + "True": 87 test-flag3788: - percentage: 88 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 12 + "True": 88 test-flag3789: - percentage: 89 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 11 + "True": 89 test-flag3790: - percentage: 90 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 10 + "True": 90 test-flag3791: - percentage: 91 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 9 + "True": 91 test-flag3792: - percentage: 92 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 8 + "True": 92 test-flag3793: - percentage: 93 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 7 + "True": 93 test-flag3794: - percentage: 94 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 6 + "True": 94 test-flag3795: - percentage: 95 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 5 + "True": 95 test-flag3796: - percentage: 96 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 4 + "True": 96 test-flag3797: - percentage: 97 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 3 + "True": 97 test-flag3798: - percentage: 98 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 2 + "True": 98 test-flag3799: - percentage: 99 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 1 + "True": 99 test-flag3800: - percentage: 0 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 100 + "True": 0 test-flag3801: - percentage: 1 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 99 + "True": 1 test-flag3802: - percentage: 2 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 98 + "True": 2 test-flag3803: - percentage: 3 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 97 + "True": 3 test-flag3804: - percentage: 4 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 96 + "True": 4 test-flag3805: - percentage: 5 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 95 + "True": 5 test-flag3806: - percentage: 6 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 94 + "True": 6 test-flag3807: - percentage: 7 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 93 + "True": 7 test-flag3808: - percentage: 8 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 92 + "True": 8 test-flag3809: - percentage: 9 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 91 + "True": 9 test-flag3810: - percentage: 10 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 90 + "True": 10 test-flag3811: - percentage: 11 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 89 + "True": 11 test-flag3812: - percentage: 12 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 88 + "True": 12 test-flag3813: - percentage: 13 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 87 + "True": 13 test-flag3814: - percentage: 14 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 86 + "True": 14 test-flag3815: - percentage: 15 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 85 + "True": 15 test-flag3816: - percentage: 16 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 84 + "True": 16 test-flag3817: - percentage: 17 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 83 + "True": 17 test-flag3818: - percentage: 18 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 82 + "True": 18 test-flag3819: - percentage: 19 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 81 + "True": 19 test-flag3820: - percentage: 20 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 80 + "True": 20 test-flag3821: - percentage: 21 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 79 + "True": 21 test-flag3822: - percentage: 22 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 78 + "True": 22 test-flag3823: - percentage: 23 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 77 + "True": 23 test-flag3824: - percentage: 24 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 76 + "True": 24 test-flag3825: - percentage: 25 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 75 + "True": 25 test-flag3826: - percentage: 26 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 74 + "True": 26 test-flag3827: - percentage: 27 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 73 + "True": 27 test-flag3828: - percentage: 28 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 72 + "True": 28 test-flag3829: - percentage: 29 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 71 + "True": 29 test-flag3830: - percentage: 30 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 70 + "True": 30 test-flag3831: - percentage: 31 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 69 + "True": 31 test-flag3832: - percentage: 32 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 68 + "True": 32 test-flag3833: - percentage: 33 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 67 + "True": 33 test-flag3834: - percentage: 34 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 66 + "True": 34 test-flag3835: - percentage: 35 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 65 + "True": 35 test-flag3836: - percentage: 36 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 64 + "True": 36 test-flag3837: - percentage: 37 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 63 + "True": 37 test-flag3838: - percentage: 38 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 62 + "True": 38 test-flag3839: - percentage: 39 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 61 + "True": 39 test-flag3840: - percentage: 40 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 60 + "True": 40 test-flag3841: - percentage: 41 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 59 + "True": 41 test-flag3842: - percentage: 42 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 58 + "True": 42 test-flag3843: - percentage: 43 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 57 + "True": 43 test-flag3844: - percentage: 44 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 56 + "True": 44 test-flag3845: - percentage: 45 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 55 + "True": 45 test-flag3846: - percentage: 46 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 54 + "True": 46 test-flag3847: - percentage: 47 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 53 + "True": 47 test-flag3848: - percentage: 48 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 52 + "True": 48 test-flag3849: - percentage: 49 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 51 + "True": 49 test-flag3850: - percentage: 50 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 50 + "True": 50 test-flag3851: - percentage: 51 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 49 + "True": 51 test-flag3852: - percentage: 52 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 48 + "True": 52 test-flag3853: - percentage: 53 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 47 + "True": 53 test-flag3854: - percentage: 54 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 46 + "True": 54 test-flag3855: - percentage: 55 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 45 + "True": 55 test-flag3856: - percentage: 56 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 44 + "True": 56 test-flag3857: - percentage: 57 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 43 + "True": 57 test-flag3858: - percentage: 58 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 42 + "True": 58 test-flag3859: - percentage: 59 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 41 + "True": 59 test-flag3860: - percentage: 60 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 40 + "True": 60 test-flag3861: - percentage: 61 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 39 + "True": 61 test-flag3862: - percentage: 62 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 38 + "True": 62 test-flag3863: - percentage: 63 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 37 + "True": 63 test-flag3864: - percentage: 64 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 36 + "True": 64 test-flag3865: - percentage: 65 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 35 + "True": 65 test-flag3866: - percentage: 66 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 34 + "True": 66 test-flag3867: - percentage: 67 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 33 + "True": 67 test-flag3868: - percentage: 68 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 32 + "True": 68 test-flag3869: - percentage: 69 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 31 + "True": 69 test-flag3870: - percentage: 70 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 30 + "True": 70 test-flag3871: - percentage: 71 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 29 + "True": 71 test-flag3872: - percentage: 72 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 28 + "True": 72 test-flag3873: - percentage: 73 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 27 + "True": 73 test-flag3874: - percentage: 74 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 26 + "True": 74 test-flag3875: - percentage: 75 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 25 + "True": 75 test-flag3876: - percentage: 76 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 24 + "True": 76 test-flag3877: - percentage: 77 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 23 + "True": 77 test-flag3878: - percentage: 78 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 22 + "True": 78 test-flag3879: - percentage: 79 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 21 + "True": 79 test-flag3880: - percentage: 80 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 20 + "True": 80 test-flag3881: - percentage: 81 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 19 + "True": 81 test-flag3882: - percentage: 82 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 18 + "True": 82 test-flag3883: - percentage: 83 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 17 + "True": 83 test-flag3884: - percentage: 84 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 16 + "True": 84 test-flag3885: - percentage: 85 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 15 + "True": 85 test-flag3886: - percentage: 86 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 14 + "True": 86 test-flag3887: - percentage: 87 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 13 + "True": 87 test-flag3888: - percentage: 88 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 12 + "True": 88 test-flag3889: - percentage: 89 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 11 + "True": 89 test-flag3890: - percentage: 90 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 10 + "True": 90 test-flag3891: - percentage: 91 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 9 + "True": 91 test-flag3892: - percentage: 92 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 8 + "True": 92 test-flag3893: - percentage: 93 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 7 + "True": 93 test-flag3894: - percentage: 94 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 6 + "True": 94 test-flag3895: - percentage: 95 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 5 + "True": 95 test-flag3896: - percentage: 96 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 4 + "True": 96 test-flag3897: - percentage: 97 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 3 + "True": 97 test-flag3898: - percentage: 98 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 2 + "True": 98 test-flag3899: - percentage: 99 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 1 + "True": 99 test-flag3900: - percentage: 0 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 100 + "True": 0 test-flag3901: - percentage: 1 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 99 + "True": 1 test-flag3902: - percentage: 2 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 98 + "True": 2 test-flag3903: - percentage: 3 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 97 + "True": 3 test-flag3904: - percentage: 4 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 96 + "True": 4 test-flag3905: - percentage: 5 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 95 + "True": 5 test-flag3906: - percentage: 6 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 94 + "True": 6 test-flag3907: - percentage: 7 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 93 + "True": 7 test-flag3908: - percentage: 8 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 92 + "True": 8 test-flag3909: - percentage: 9 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 91 + "True": 9 test-flag3910: - percentage: 10 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 90 + "True": 10 test-flag3911: - percentage: 11 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 89 + "True": 11 test-flag3912: - percentage: 12 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 88 + "True": 12 test-flag3913: - percentage: 13 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 87 + "True": 13 test-flag3914: - percentage: 14 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 86 + "True": 14 test-flag3915: - percentage: 15 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 85 + "True": 15 test-flag3916: - percentage: 16 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 84 + "True": 16 test-flag3917: - percentage: 17 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 83 + "True": 17 test-flag3918: - percentage: 18 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 82 + "True": 18 test-flag3919: - percentage: 19 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 81 + "True": 19 test-flag3920: - percentage: 20 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 80 + "True": 20 test-flag3921: - percentage: 21 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 79 + "True": 21 test-flag3922: - percentage: 22 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 78 + "True": 22 test-flag3923: - percentage: 23 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 77 + "True": 23 test-flag3924: - percentage: 24 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 76 + "True": 24 test-flag3925: - percentage: 25 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 75 + "True": 25 test-flag3926: - percentage: 26 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 74 + "True": 26 test-flag3927: - percentage: 27 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 73 + "True": 27 test-flag3928: - percentage: 28 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 72 + "True": 28 test-flag3929: - percentage: 29 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 71 + "True": 29 test-flag3930: - percentage: 30 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 70 + "True": 30 test-flag3931: - percentage: 31 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 69 + "True": 31 test-flag3932: - percentage: 32 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 68 + "True": 32 test-flag3933: - percentage: 33 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 67 + "True": 33 test-flag3934: - percentage: 34 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 66 + "True": 34 test-flag3935: - percentage: 35 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 65 + "True": 35 test-flag3936: - percentage: 36 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 64 + "True": 36 test-flag3937: - percentage: 37 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 63 + "True": 37 test-flag3938: - percentage: 38 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 62 + "True": 38 test-flag3939: - percentage: 39 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 61 + "True": 39 test-flag3940: - percentage: 40 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 60 + "True": 40 test-flag3941: - percentage: 41 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 59 + "True": 41 test-flag3942: - percentage: 42 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 58 + "True": 42 test-flag3943: - percentage: 43 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 57 + "True": 43 test-flag3944: - percentage: 44 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 56 + "True": 44 test-flag3945: - percentage: 45 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 55 + "True": 45 test-flag3946: - percentage: 46 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 54 + "True": 46 test-flag3947: - percentage: 47 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 53 + "True": 47 test-flag3948: - percentage: 48 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 52 + "True": 48 test-flag3949: - percentage: 49 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 51 + "True": 49 test-flag3950: - percentage: 50 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 50 + "True": 50 test-flag3951: - percentage: 51 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 49 + "True": 51 test-flag3952: - percentage: 52 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 48 + "True": 52 test-flag3953: - percentage: 53 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 47 + "True": 53 test-flag3954: - percentage: 54 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 46 + "True": 54 test-flag3955: - percentage: 55 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 45 + "True": 55 test-flag3956: - percentage: 56 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 44 + "True": 56 test-flag3957: - percentage: 57 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 43 + "True": 57 test-flag3958: - percentage: 58 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 42 + "True": 58 test-flag3959: - percentage: 59 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 41 + "True": 59 test-flag3960: - percentage: 60 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 40 + "True": 60 test-flag3961: - percentage: 61 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 39 + "True": 61 test-flag3962: - percentage: 62 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 38 + "True": 62 test-flag3963: - percentage: 63 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 37 + "True": 63 test-flag3964: - percentage: 64 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 36 + "True": 64 test-flag3965: - percentage: 65 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 35 + "True": 65 test-flag3966: - percentage: 66 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 34 + "True": 66 test-flag3967: - percentage: 67 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 33 + "True": 67 test-flag3968: - percentage: 68 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 32 + "True": 68 test-flag3969: - percentage: 69 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 31 + "True": 69 test-flag3970: - percentage: 70 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 30 + "True": 70 test-flag3971: - percentage: 71 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 29 + "True": 71 test-flag3972: - percentage: 72 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 28 + "True": 72 test-flag3973: - percentage: 73 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 27 + "True": 73 test-flag3974: - percentage: 74 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 26 + "True": 74 test-flag3975: - percentage: 75 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 25 + "True": 75 test-flag3976: - percentage: 76 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 24 + "True": 76 test-flag3977: - percentage: 77 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 23 + "True": 77 test-flag3978: - percentage: 78 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 22 + "True": 78 test-flag3979: - percentage: 79 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 21 + "True": 79 test-flag3980: - percentage: 80 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 20 + "True": 80 test-flag3981: - percentage: 81 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 19 + "True": 81 test-flag3982: - percentage: 82 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 18 + "True": 82 test-flag3983: - percentage: 83 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 17 + "True": 83 test-flag3984: - percentage: 84 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 16 + "True": 84 test-flag3985: - percentage: 85 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 15 + "True": 85 test-flag3986: - percentage: 86 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 14 + "True": 86 test-flag3987: - percentage: 87 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 13 + "True": 87 test-flag3988: - percentage: 88 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 12 + "True": 88 test-flag3989: - percentage: 89 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 11 + "True": 89 test-flag3990: - percentage: 90 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 10 + "True": 90 test-flag3991: - percentage: 91 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 9 + "True": 91 test-flag3992: - percentage: 92 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 8 + "True": 92 test-flag3993: - percentage: 93 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 7 + "True": 93 test-flag3994: - percentage: 94 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 6 + "True": 94 test-flag3995: - percentage: 95 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 5 + "True": 95 test-flag3996: - percentage: 96 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 4 + "True": 96 test-flag3997: - percentage: 97 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 3 + "True": 97 test-flag3998: - percentage: 98 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 2 + "True": 98 test-flag3999: - percentage: 99 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 1 + "True": 99 test-flag4000: - percentage: 0 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 100 + "True": 0 test-flag4001: - percentage: 1 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 99 + "True": 1 test-flag4002: - percentage: 2 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 98 + "True": 2 test-flag4003: - percentage: 3 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 97 + "True": 3 test-flag4004: - percentage: 4 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 96 + "True": 4 test-flag4005: - percentage: 5 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 95 + "True": 5 test-flag4006: - percentage: 6 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 94 + "True": 6 test-flag4007: - percentage: 7 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 93 + "True": 7 test-flag4008: - percentage: 8 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 92 + "True": 8 test-flag4009: - percentage: 9 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 91 + "True": 9 test-flag4010: - percentage: 10 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 90 + "True": 10 test-flag4011: - percentage: 11 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 89 + "True": 11 test-flag4012: - percentage: 12 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 88 + "True": 12 test-flag4013: - percentage: 13 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 87 + "True": 13 test-flag4014: - percentage: 14 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 86 + "True": 14 test-flag4015: - percentage: 15 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 85 + "True": 15 test-flag4016: - percentage: 16 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 84 + "True": 16 test-flag4017: - percentage: 17 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 83 + "True": 17 test-flag4018: - percentage: 18 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 82 + "True": 18 test-flag4019: - percentage: 19 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 81 + "True": 19 test-flag4020: - percentage: 20 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 80 + "True": 20 test-flag4021: - percentage: 21 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 79 + "True": 21 test-flag4022: - percentage: 22 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 78 + "True": 22 test-flag4023: - percentage: 23 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 77 + "True": 23 test-flag4024: - percentage: 24 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 76 + "True": 24 test-flag4025: - percentage: 25 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 75 + "True": 25 test-flag4026: - percentage: 26 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 74 + "True": 26 test-flag4027: - percentage: 27 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 73 + "True": 27 test-flag4028: - percentage: 28 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 72 + "True": 28 test-flag4029: - percentage: 29 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 71 + "True": 29 test-flag4030: - percentage: 30 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 70 + "True": 30 test-flag4031: - percentage: 31 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 69 + "True": 31 test-flag4032: - percentage: 32 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 68 + "True": 32 test-flag4033: - percentage: 33 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 67 + "True": 33 test-flag4034: - percentage: 34 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 66 + "True": 34 test-flag4035: - percentage: 35 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 65 + "True": 35 test-flag4036: - percentage: 36 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 64 + "True": 36 test-flag4037: - percentage: 37 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 63 + "True": 37 test-flag4038: - percentage: 38 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 62 + "True": 38 test-flag4039: - percentage: 39 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 61 + "True": 39 test-flag4040: - percentage: 40 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 60 + "True": 40 test-flag4041: - percentage: 41 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 59 + "True": 41 test-flag4042: - percentage: 42 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 58 + "True": 42 test-flag4043: - percentage: 43 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 57 + "True": 43 test-flag4044: - percentage: 44 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 56 + "True": 44 test-flag4045: - percentage: 45 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 55 + "True": 45 test-flag4046: - percentage: 46 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 54 + "True": 46 test-flag4047: - percentage: 47 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 53 + "True": 47 test-flag4048: - percentage: 48 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 52 + "True": 48 test-flag4049: - percentage: 49 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 51 + "True": 49 test-flag4050: - percentage: 50 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 50 + "True": 50 test-flag4051: - percentage: 51 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 49 + "True": 51 test-flag4052: - percentage: 52 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 48 + "True": 52 test-flag4053: - percentage: 53 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 47 + "True": 53 test-flag4054: - percentage: 54 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 46 + "True": 54 test-flag4055: - percentage: 55 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 45 + "True": 55 test-flag4056: - percentage: 56 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 44 + "True": 56 test-flag4057: - percentage: 57 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 43 + "True": 57 test-flag4058: - percentage: 58 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 42 + "True": 58 test-flag4059: - percentage: 59 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 41 + "True": 59 test-flag4060: - percentage: 60 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 40 + "True": 60 test-flag4061: - percentage: 61 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 39 + "True": 61 test-flag4062: - percentage: 62 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 38 + "True": 62 test-flag4063: - percentage: 63 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 37 + "True": 63 test-flag4064: - percentage: 64 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 36 + "True": 64 test-flag4065: - percentage: 65 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 35 + "True": 65 test-flag4066: - percentage: 66 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 34 + "True": 66 test-flag4067: - percentage: 67 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 33 + "True": 67 test-flag4068: - percentage: 68 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 32 + "True": 68 test-flag4069: - percentage: 69 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 31 + "True": 69 test-flag4070: - percentage: 70 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 30 + "True": 70 test-flag4071: - percentage: 71 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 29 + "True": 71 test-flag4072: - percentage: 72 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 28 + "True": 72 test-flag4073: - percentage: 73 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 27 + "True": 73 test-flag4074: - percentage: 74 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 26 + "True": 74 test-flag4075: - percentage: 75 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 25 + "True": 75 test-flag4076: - percentage: 76 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 24 + "True": 76 test-flag4077: - percentage: 77 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 23 + "True": 77 test-flag4078: - percentage: 78 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 22 + "True": 78 test-flag4079: - percentage: 79 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 21 + "True": 79 test-flag4080: - percentage: 80 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 20 + "True": 80 test-flag4081: - percentage: 81 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 19 + "True": 81 test-flag4082: - percentage: 82 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 18 + "True": 82 test-flag4083: - percentage: 83 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 17 + "True": 83 test-flag4084: - percentage: 84 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 16 + "True": 84 test-flag4085: - percentage: 85 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 15 + "True": 85 test-flag4086: - percentage: 86 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 14 + "True": 86 test-flag4087: - percentage: 87 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 13 + "True": 87 test-flag4088: - percentage: 88 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 12 + "True": 88 test-flag4089: - percentage: 89 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 11 + "True": 89 test-flag4090: - percentage: 90 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 10 + "True": 90 test-flag4091: - percentage: 91 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 9 + "True": 91 test-flag4092: - percentage: 92 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 8 + "True": 92 test-flag4093: - percentage: 93 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 7 + "True": 93 test-flag4094: - percentage: 94 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 6 + "True": 94 test-flag4095: - percentage: 95 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 5 + "True": 95 test-flag4096: - percentage: 96 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 4 + "True": 96 test-flag4097: - percentage: 97 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 3 + "True": 97 test-flag4098: - percentage: 98 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 2 + "True": 98 test-flag4099: - percentage: 99 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 1 + "True": 99 test-flag4100: - percentage: 0 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 100 + "True": 0 test-flag4101: - percentage: 1 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 99 + "True": 1 test-flag4102: - percentage: 2 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 98 + "True": 2 test-flag4103: - percentage: 3 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 97 + "True": 3 test-flag4104: - percentage: 4 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 96 + "True": 4 test-flag4105: - percentage: 5 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 95 + "True": 5 test-flag4106: - percentage: 6 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 94 + "True": 6 test-flag4107: - percentage: 7 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 93 + "True": 7 test-flag4108: - percentage: 8 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 92 + "True": 8 test-flag4109: - percentage: 9 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 91 + "True": 9 test-flag4110: - percentage: 10 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 90 + "True": 10 test-flag4111: - percentage: 11 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 89 + "True": 11 test-flag4112: - percentage: 12 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 88 + "True": 12 test-flag4113: - percentage: 13 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 87 + "True": 13 test-flag4114: - percentage: 14 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 86 + "True": 14 test-flag4115: - percentage: 15 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 85 + "True": 15 test-flag4116: - percentage: 16 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 84 + "True": 16 test-flag4117: - percentage: 17 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 83 + "True": 17 test-flag4118: - percentage: 18 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 82 + "True": 18 test-flag4119: - percentage: 19 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 81 + "True": 19 test-flag4120: - percentage: 20 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 80 + "True": 20 test-flag4121: - percentage: 21 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 79 + "True": 21 test-flag4122: - percentage: 22 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 78 + "True": 22 test-flag4123: - percentage: 23 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 77 + "True": 23 test-flag4124: - percentage: 24 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 76 + "True": 24 test-flag4125: - percentage: 25 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 75 + "True": 25 test-flag4126: - percentage: 26 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 74 + "True": 26 test-flag4127: - percentage: 27 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 73 + "True": 27 test-flag4128: - percentage: 28 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 72 + "True": 28 test-flag4129: - percentage: 29 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 71 + "True": 29 test-flag4130: - percentage: 30 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 70 + "True": 30 test-flag4131: - percentage: 31 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 69 + "True": 31 test-flag4132: - percentage: 32 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 68 + "True": 32 test-flag4133: - percentage: 33 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 67 + "True": 33 test-flag4134: - percentage: 34 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 66 + "True": 34 test-flag4135: - percentage: 35 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 65 + "True": 35 test-flag4136: - percentage: 36 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 64 + "True": 36 test-flag4137: - percentage: 37 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 63 + "True": 37 test-flag4138: - percentage: 38 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 62 + "True": 38 test-flag4139: - percentage: 39 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 61 + "True": 39 test-flag4140: - percentage: 40 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 60 + "True": 40 test-flag4141: - percentage: 41 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 59 + "True": 41 test-flag4142: - percentage: 42 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 58 + "True": 42 test-flag4143: - percentage: 43 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 57 + "True": 43 test-flag4144: - percentage: 44 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 56 + "True": 44 test-flag4145: - percentage: 45 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 55 + "True": 45 test-flag4146: - percentage: 46 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 54 + "True": 46 test-flag4147: - percentage: 47 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 53 + "True": 47 test-flag4148: - percentage: 48 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 52 + "True": 48 test-flag4149: - percentage: 49 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 51 + "True": 49 test-flag4150: - percentage: 50 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 50 + "True": 50 test-flag4151: - percentage: 51 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 49 + "True": 51 test-flag4152: - percentage: 52 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 48 + "True": 52 test-flag4153: - percentage: 53 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 47 + "True": 53 test-flag4154: - percentage: 54 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 46 + "True": 54 test-flag4155: - percentage: 55 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 45 + "True": 55 test-flag4156: - percentage: 56 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 44 + "True": 56 test-flag4157: - percentage: 57 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 43 + "True": 57 test-flag4158: - percentage: 58 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 42 + "True": 58 test-flag4159: - percentage: 59 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 41 + "True": 59 test-flag4160: - percentage: 60 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 40 + "True": 60 test-flag4161: - percentage: 61 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 39 + "True": 61 test-flag4162: - percentage: 62 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 38 + "True": 62 test-flag4163: - percentage: 63 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 37 + "True": 63 test-flag4164: - percentage: 64 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 36 + "True": 64 test-flag4165: - percentage: 65 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 35 + "True": 65 test-flag4166: - percentage: 66 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 34 + "True": 66 test-flag4167: - percentage: 67 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 33 + "True": 67 test-flag4168: - percentage: 68 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 32 + "True": 68 test-flag4169: - percentage: 69 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 31 + "True": 69 test-flag4170: - percentage: 70 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 30 + "True": 70 test-flag4171: - percentage: 71 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 29 + "True": 71 test-flag4172: - percentage: 72 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 28 + "True": 72 test-flag4173: - percentage: 73 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 27 + "True": 73 test-flag4174: - percentage: 74 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 26 + "True": 74 test-flag4175: - percentage: 75 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 25 + "True": 75 test-flag4176: - percentage: 76 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 24 + "True": 76 test-flag4177: - percentage: 77 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 23 + "True": 77 test-flag4178: - percentage: 78 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 22 + "True": 78 test-flag4179: - percentage: 79 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 21 + "True": 79 test-flag4180: - percentage: 80 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 20 + "True": 80 test-flag4181: - percentage: 81 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 19 + "True": 81 test-flag4182: - percentage: 82 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 18 + "True": 82 test-flag4183: - percentage: 83 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 17 + "True": 83 test-flag4184: - percentage: 84 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 16 + "True": 84 test-flag4185: - percentage: 85 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 15 + "True": 85 test-flag4186: - percentage: 86 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 14 + "True": 86 test-flag4187: - percentage: 87 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 13 + "True": 87 test-flag4188: - percentage: 88 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 12 + "True": 88 test-flag4189: - percentage: 89 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 11 + "True": 89 test-flag4190: - percentage: 90 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 10 + "True": 90 test-flag4191: - percentage: 91 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 9 + "True": 91 test-flag4192: - percentage: 92 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 8 + "True": 92 test-flag4193: - percentage: 93 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 7 + "True": 93 test-flag4194: - percentage: 94 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 6 + "True": 94 test-flag4195: - percentage: 95 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 5 + "True": 95 test-flag4196: - percentage: 96 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 4 + "True": 96 test-flag4197: - percentage: 97 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 3 + "True": 97 test-flag4198: - percentage: 98 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 2 + "True": 98 test-flag4199: - percentage: 99 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 1 + "True": 99 test-flag4200: - percentage: 0 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 100 + "True": 0 test-flag4201: - percentage: 1 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 99 + "True": 1 test-flag4202: - percentage: 2 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 98 + "True": 2 test-flag4203: - percentage: 3 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 97 + "True": 3 test-flag4204: - percentage: 4 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 96 + "True": 4 test-flag4205: - percentage: 5 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 95 + "True": 5 test-flag4206: - percentage: 6 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 94 + "True": 6 test-flag4207: - percentage: 7 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 93 + "True": 7 test-flag4208: - percentage: 8 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 92 + "True": 8 test-flag4209: - percentage: 9 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 91 + "True": 9 test-flag4210: - percentage: 10 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 90 + "True": 10 test-flag4211: - percentage: 11 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 89 + "True": 11 test-flag4212: - percentage: 12 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 88 + "True": 12 test-flag4213: - percentage: 13 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 87 + "True": 13 test-flag4214: - percentage: 14 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 86 + "True": 14 test-flag4215: - percentage: 15 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 85 + "True": 15 test-flag4216: - percentage: 16 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 84 + "True": 16 test-flag4217: - percentage: 17 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 83 + "True": 17 test-flag4218: - percentage: 18 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 82 + "True": 18 test-flag4219: - percentage: 19 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 81 + "True": 19 test-flag4220: - percentage: 20 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 80 + "True": 20 test-flag4221: - percentage: 21 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 79 + "True": 21 test-flag4222: - percentage: 22 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 78 + "True": 22 test-flag4223: - percentage: 23 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 77 + "True": 23 test-flag4224: - percentage: 24 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 76 + "True": 24 test-flag4225: - percentage: 25 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 75 + "True": 25 test-flag4226: - percentage: 26 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 74 + "True": 26 test-flag4227: - percentage: 27 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 73 + "True": 27 test-flag4228: - percentage: 28 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 72 + "True": 28 test-flag4229: - percentage: 29 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 71 + "True": 29 test-flag4230: - percentage: 30 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 70 + "True": 30 test-flag4231: - percentage: 31 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 69 + "True": 31 test-flag4232: - percentage: 32 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 68 + "True": 32 test-flag4233: - percentage: 33 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 67 + "True": 33 test-flag4234: - percentage: 34 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 66 + "True": 34 test-flag4235: - percentage: 35 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 65 + "True": 35 test-flag4236: - percentage: 36 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 64 + "True": 36 test-flag4237: - percentage: 37 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 63 + "True": 37 test-flag4238: - percentage: 38 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 62 + "True": 38 test-flag4239: - percentage: 39 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 61 + "True": 39 test-flag4240: - percentage: 40 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 60 + "True": 40 test-flag4241: - percentage: 41 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 59 + "True": 41 test-flag4242: - percentage: 42 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 58 + "True": 42 test-flag4243: - percentage: 43 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 57 + "True": 43 test-flag4244: - percentage: 44 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 56 + "True": 44 test-flag4245: - percentage: 45 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 55 + "True": 45 test-flag4246: - percentage: 46 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 54 + "True": 46 test-flag4247: - percentage: 47 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 53 + "True": 47 test-flag4248: - percentage: 48 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 52 + "True": 48 test-flag4249: - percentage: 49 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 51 + "True": 49 test-flag4250: - percentage: 50 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 50 + "True": 50 test-flag4251: - percentage: 51 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 49 + "True": 51 test-flag4252: - percentage: 52 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 48 + "True": 52 test-flag4253: - percentage: 53 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 47 + "True": 53 test-flag4254: - percentage: 54 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 46 + "True": 54 test-flag4255: - percentage: 55 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 45 + "True": 55 test-flag4256: - percentage: 56 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 44 + "True": 56 test-flag4257: - percentage: 57 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 43 + "True": 57 test-flag4258: - percentage: 58 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 42 + "True": 58 test-flag4259: - percentage: 59 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 41 + "True": 59 test-flag4260: - percentage: 60 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 40 + "True": 60 test-flag4261: - percentage: 61 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 39 + "True": 61 test-flag4262: - percentage: 62 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 38 + "True": 62 test-flag4263: - percentage: 63 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 37 + "True": 63 test-flag4264: - percentage: 64 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 36 + "True": 64 test-flag4265: - percentage: 65 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 35 + "True": 65 test-flag4266: - percentage: 66 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 34 + "True": 66 test-flag4267: - percentage: 67 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 33 + "True": 67 test-flag4268: - percentage: 68 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 32 + "True": 68 test-flag4269: - percentage: 69 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 31 + "True": 69 test-flag4270: - percentage: 70 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 30 + "True": 70 test-flag4271: - percentage: 71 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 29 + "True": 71 test-flag4272: - percentage: 72 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 28 + "True": 72 test-flag4273: - percentage: 73 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 27 + "True": 73 test-flag4274: - percentage: 74 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 26 + "True": 74 test-flag4275: - percentage: 75 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 25 + "True": 75 test-flag4276: - percentage: 76 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 24 + "True": 76 test-flag4277: - percentage: 77 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 23 + "True": 77 test-flag4278: - percentage: 78 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 22 + "True": 78 test-flag4279: - percentage: 79 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 21 + "True": 79 test-flag4280: - percentage: 80 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 20 + "True": 80 test-flag4281: - percentage: 81 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 19 + "True": 81 test-flag4282: - percentage: 82 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 18 + "True": 82 test-flag4283: - percentage: 83 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 17 + "True": 83 test-flag4284: - percentage: 84 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 16 + "True": 84 test-flag4285: - percentage: 85 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 15 + "True": 85 test-flag4286: - percentage: 86 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 14 + "True": 86 test-flag4287: - percentage: 87 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 13 + "True": 87 test-flag4288: - percentage: 88 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 12 + "True": 88 test-flag4289: - percentage: 89 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 11 + "True": 89 test-flag4290: - percentage: 90 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 10 + "True": 90 test-flag4291: - percentage: 91 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 9 + "True": 91 test-flag4292: - percentage: 92 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 8 + "True": 92 test-flag4293: - percentage: 93 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 7 + "True": 93 test-flag4294: - percentage: 94 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 6 + "True": 94 test-flag4295: - percentage: 95 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 5 + "True": 95 test-flag4296: - percentage: 96 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 4 + "True": 96 test-flag4297: - percentage: 97 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 3 + "True": 97 test-flag4298: - percentage: 98 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 2 + "True": 98 test-flag4299: - percentage: 99 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 1 + "True": 99 test-flag4300: - percentage: 0 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 100 + "True": 0 test-flag4301: - percentage: 1 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 99 + "True": 1 test-flag4302: - percentage: 2 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 98 + "True": 2 test-flag4303: - percentage: 3 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 97 + "True": 3 test-flag4304: - percentage: 4 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 96 + "True": 4 test-flag4305: - percentage: 5 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 95 + "True": 5 test-flag4306: - percentage: 6 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 94 + "True": 6 test-flag4307: - percentage: 7 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 93 + "True": 7 test-flag4308: - percentage: 8 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 92 + "True": 8 test-flag4309: - percentage: 9 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 91 + "True": 9 test-flag4310: - percentage: 10 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 90 + "True": 10 test-flag4311: - percentage: 11 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 89 + "True": 11 test-flag4312: - percentage: 12 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 88 + "True": 12 test-flag4313: - percentage: 13 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 87 + "True": 13 test-flag4314: - percentage: 14 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 86 + "True": 14 test-flag4315: - percentage: 15 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 85 + "True": 15 test-flag4316: - percentage: 16 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 84 + "True": 16 test-flag4317: - percentage: 17 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 83 + "True": 17 test-flag4318: - percentage: 18 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 82 + "True": 18 test-flag4319: - percentage: 19 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 81 + "True": 19 test-flag4320: - percentage: 20 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 80 + "True": 20 test-flag4321: - percentage: 21 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 79 + "True": 21 test-flag4322: - percentage: 22 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 78 + "True": 22 test-flag4323: - percentage: 23 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 77 + "True": 23 test-flag4324: - percentage: 24 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 76 + "True": 24 test-flag4325: - percentage: 25 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 75 + "True": 25 test-flag4326: - percentage: 26 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 74 + "True": 26 test-flag4327: - percentage: 27 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 73 + "True": 27 test-flag4328: - percentage: 28 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 72 + "True": 28 test-flag4329: - percentage: 29 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 71 + "True": 29 test-flag4330: - percentage: 30 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 70 + "True": 30 test-flag4331: - percentage: 31 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 69 + "True": 31 test-flag4332: - percentage: 32 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 68 + "True": 32 test-flag4333: - percentage: 33 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 67 + "True": 33 test-flag4334: - percentage: 34 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 66 + "True": 34 test-flag4335: - percentage: 35 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 65 + "True": 35 test-flag4336: - percentage: 36 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 64 + "True": 36 test-flag4337: - percentage: 37 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 63 + "True": 37 test-flag4338: - percentage: 38 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 62 + "True": 38 test-flag4339: - percentage: 39 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 61 + "True": 39 test-flag4340: - percentage: 40 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 60 + "True": 40 test-flag4341: - percentage: 41 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 59 + "True": 41 test-flag4342: - percentage: 42 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 58 + "True": 42 test-flag4343: - percentage: 43 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 57 + "True": 43 test-flag4344: - percentage: 44 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 56 + "True": 44 test-flag4345: - percentage: 45 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 55 + "True": 45 test-flag4346: - percentage: 46 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 54 + "True": 46 test-flag4347: - percentage: 47 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 53 + "True": 47 test-flag4348: - percentage: 48 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 52 + "True": 48 test-flag4349: - percentage: 49 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 51 + "True": 49 test-flag4350: - percentage: 50 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 50 + "True": 50 test-flag4351: - percentage: 51 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 49 + "True": 51 test-flag4352: - percentage: 52 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 48 + "True": 52 test-flag4353: - percentage: 53 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 47 + "True": 53 test-flag4354: - percentage: 54 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 46 + "True": 54 test-flag4355: - percentage: 55 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 45 + "True": 55 test-flag4356: - percentage: 56 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 44 + "True": 56 test-flag4357: - percentage: 57 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 43 + "True": 57 test-flag4358: - percentage: 58 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 42 + "True": 58 test-flag4359: - percentage: 59 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 41 + "True": 59 test-flag4360: - percentage: 60 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 40 + "True": 60 test-flag4361: - percentage: 61 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 39 + "True": 61 test-flag4362: - percentage: 62 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 38 + "True": 62 test-flag4363: - percentage: 63 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 37 + "True": 63 test-flag4364: - percentage: 64 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 36 + "True": 64 test-flag4365: - percentage: 65 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 35 + "True": 65 test-flag4366: - percentage: 66 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 34 + "True": 66 test-flag4367: - percentage: 67 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 33 + "True": 67 test-flag4368: - percentage: 68 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 32 + "True": 68 test-flag4369: - percentage: 69 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 31 + "True": 69 test-flag4370: - percentage: 70 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 30 + "True": 70 test-flag4371: - percentage: 71 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 29 + "True": 71 test-flag4372: - percentage: 72 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 28 + "True": 72 test-flag4373: - percentage: 73 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 27 + "True": 73 test-flag4374: - percentage: 74 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 26 + "True": 74 test-flag4375: - percentage: 75 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 25 + "True": 75 test-flag4376: - percentage: 76 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 24 + "True": 76 test-flag4377: - percentage: 77 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 23 + "True": 77 test-flag4378: - percentage: 78 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 22 + "True": 78 test-flag4379: - percentage: 79 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 21 + "True": 79 test-flag4380: - percentage: 80 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 20 + "True": 80 test-flag4381: - percentage: 81 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 19 + "True": 81 test-flag4382: - percentage: 82 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 18 + "True": 82 test-flag4383: - percentage: 83 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 17 + "True": 83 test-flag4384: - percentage: 84 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 16 + "True": 84 test-flag4385: - percentage: 85 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 15 + "True": 85 test-flag4386: - percentage: 86 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 14 + "True": 86 test-flag4387: - percentage: 87 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 13 + "True": 87 test-flag4388: - percentage: 88 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 12 + "True": 88 test-flag4389: - percentage: 89 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 11 + "True": 89 test-flag4390: - percentage: 90 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 10 + "True": 90 test-flag4391: - percentage: 91 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 9 + "True": 91 test-flag4392: - percentage: 92 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 8 + "True": 92 test-flag4393: - percentage: 93 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 7 + "True": 93 test-flag4394: - percentage: 94 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 6 + "True": 94 test-flag4395: - percentage: 95 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 5 + "True": 95 test-flag4396: - percentage: 96 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 4 + "True": 96 test-flag4397: - percentage: 97 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 3 + "True": 97 test-flag4398: - percentage: 98 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 2 + "True": 98 test-flag4399: - percentage: 99 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 1 + "True": 99 test-flag4400: - percentage: 0 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 100 + "True": 0 test-flag4401: - percentage: 1 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 99 + "True": 1 test-flag4402: - percentage: 2 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 98 + "True": 2 test-flag4403: - percentage: 3 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 97 + "True": 3 test-flag4404: - percentage: 4 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 96 + "True": 4 test-flag4405: - percentage: 5 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 95 + "True": 5 test-flag4406: - percentage: 6 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 94 + "True": 6 test-flag4407: - percentage: 7 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 93 + "True": 7 test-flag4408: - percentage: 8 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 92 + "True": 8 test-flag4409: - percentage: 9 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 91 + "True": 9 test-flag4410: - percentage: 10 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 90 + "True": 10 test-flag4411: - percentage: 11 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 89 + "True": 11 test-flag4412: - percentage: 12 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 88 + "True": 12 test-flag4413: - percentage: 13 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 87 + "True": 13 test-flag4414: - percentage: 14 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 86 + "True": 14 test-flag4415: - percentage: 15 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 85 + "True": 15 test-flag4416: - percentage: 16 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 84 + "True": 16 test-flag4417: - percentage: 17 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 83 + "True": 17 test-flag4418: - percentage: 18 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 82 + "True": 18 test-flag4419: - percentage: 19 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 81 + "True": 19 test-flag4420: - percentage: 20 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 80 + "True": 20 test-flag4421: - percentage: 21 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 79 + "True": 21 test-flag4422: - percentage: 22 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 78 + "True": 22 test-flag4423: - percentage: 23 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 77 + "True": 23 test-flag4424: - percentage: 24 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 76 + "True": 24 test-flag4425: - percentage: 25 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 75 + "True": 25 test-flag4426: - percentage: 26 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 74 + "True": 26 test-flag4427: - percentage: 27 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 73 + "True": 27 test-flag4428: - percentage: 28 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 72 + "True": 28 test-flag4429: - percentage: 29 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 71 + "True": 29 test-flag4430: - percentage: 30 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 70 + "True": 30 test-flag4431: - percentage: 31 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 69 + "True": 31 test-flag4432: - percentage: 32 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 68 + "True": 32 test-flag4433: - percentage: 33 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 67 + "True": 33 test-flag4434: - percentage: 34 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 66 + "True": 34 test-flag4435: - percentage: 35 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 65 + "True": 35 test-flag4436: - percentage: 36 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 64 + "True": 36 test-flag4437: - percentage: 37 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 63 + "True": 37 test-flag4438: - percentage: 38 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 62 + "True": 38 test-flag4439: - percentage: 39 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 61 + "True": 39 test-flag4440: - percentage: 40 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 60 + "True": 40 test-flag4441: - percentage: 41 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 59 + "True": 41 test-flag4442: - percentage: 42 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 58 + "True": 42 test-flag4443: - percentage: 43 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 57 + "True": 43 test-flag4444: - percentage: 44 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 56 + "True": 44 test-flag4445: - percentage: 45 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 55 + "True": 45 test-flag4446: - percentage: 46 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 54 + "True": 46 test-flag4447: - percentage: 47 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 53 + "True": 47 test-flag4448: - percentage: 48 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 52 + "True": 48 test-flag4449: - percentage: 49 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 51 + "True": 49 test-flag4450: - percentage: 50 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 50 + "True": 50 test-flag4451: - percentage: 51 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 49 + "True": 51 test-flag4452: - percentage: 52 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 48 + "True": 52 test-flag4453: - percentage: 53 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 47 + "True": 53 test-flag4454: - percentage: 54 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 46 + "True": 54 test-flag4455: - percentage: 55 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 45 + "True": 55 test-flag4456: - percentage: 56 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 44 + "True": 56 test-flag4457: - percentage: 57 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 43 + "True": 57 test-flag4458: - percentage: 58 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 42 + "True": 58 test-flag4459: - percentage: 59 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 41 + "True": 59 test-flag4460: - percentage: 60 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 40 + "True": 60 test-flag4461: - percentage: 61 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 39 + "True": 61 test-flag4462: - percentage: 62 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 38 + "True": 62 test-flag4463: - percentage: 63 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 37 + "True": 63 test-flag4464: - percentage: 64 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 36 + "True": 64 test-flag4465: - percentage: 65 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 35 + "True": 65 test-flag4466: - percentage: 66 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 34 + "True": 66 test-flag4467: - percentage: 67 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 33 + "True": 67 test-flag4468: - percentage: 68 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 32 + "True": 68 test-flag4469: - percentage: 69 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 31 + "True": 69 test-flag4470: - percentage: 70 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 30 + "True": 70 test-flag4471: - percentage: 71 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 29 + "True": 71 test-flag4472: - percentage: 72 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 28 + "True": 72 test-flag4473: - percentage: 73 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 27 + "True": 73 test-flag4474: - percentage: 74 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 26 + "True": 74 test-flag4475: - percentage: 75 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 25 + "True": 75 test-flag4476: - percentage: 76 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 24 + "True": 76 test-flag4477: - percentage: 77 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 23 + "True": 77 test-flag4478: - percentage: 78 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 22 + "True": 78 test-flag4479: - percentage: 79 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 21 + "True": 79 test-flag4480: - percentage: 80 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 20 + "True": 80 test-flag4481: - percentage: 81 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 19 + "True": 81 test-flag4482: - percentage: 82 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 18 + "True": 82 test-flag4483: - percentage: 83 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 17 + "True": 83 test-flag4484: - percentage: 84 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 16 + "True": 84 test-flag4485: - percentage: 85 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 15 + "True": 85 test-flag4486: - percentage: 86 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 14 + "True": 86 test-flag4487: - percentage: 87 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 13 + "True": 87 test-flag4488: - percentage: 88 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 12 + "True": 88 test-flag4489: - percentage: 89 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 11 + "True": 89 test-flag4490: - percentage: 90 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 10 + "True": 90 test-flag4491: - percentage: 91 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 9 + "True": 91 test-flag4492: - percentage: 92 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 8 + "True": 92 test-flag4493: - percentage: 93 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 7 + "True": 93 test-flag4494: - percentage: 94 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 6 + "True": 94 test-flag4495: - percentage: 95 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 5 + "True": 95 test-flag4496: - percentage: 96 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 4 + "True": 96 test-flag4497: - percentage: 97 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 3 + "True": 97 test-flag4498: - percentage: 98 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 2 + "True": 98 test-flag4499: - percentage: 99 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 1 + "True": 99 test-flag4500: - percentage: 0 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 100 + "True": 0 test-flag4501: - percentage: 1 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 99 + "True": 1 test-flag4502: - percentage: 2 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 98 + "True": 2 test-flag4503: - percentage: 3 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 97 + "True": 3 test-flag4504: - percentage: 4 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 96 + "True": 4 test-flag4505: - percentage: 5 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 95 + "True": 5 test-flag4506: - percentage: 6 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 94 + "True": 6 test-flag4507: - percentage: 7 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 93 + "True": 7 test-flag4508: - percentage: 8 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 92 + "True": 8 test-flag4509: - percentage: 9 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 91 + "True": 9 test-flag4510: - percentage: 10 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 90 + "True": 10 test-flag4511: - percentage: 11 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 89 + "True": 11 test-flag4512: - percentage: 12 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 88 + "True": 12 test-flag4513: - percentage: 13 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 87 + "True": 13 test-flag4514: - percentage: 14 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 86 + "True": 14 test-flag4515: - percentage: 15 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 85 + "True": 15 test-flag4516: - percentage: 16 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 84 + "True": 16 test-flag4517: - percentage: 17 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 83 + "True": 17 test-flag4518: - percentage: 18 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 82 + "True": 18 test-flag4519: - percentage: 19 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 81 + "True": 19 test-flag4520: - percentage: 20 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 80 + "True": 20 test-flag4521: - percentage: 21 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 79 + "True": 21 test-flag4522: - percentage: 22 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 78 + "True": 22 test-flag4523: - percentage: 23 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 77 + "True": 23 test-flag4524: - percentage: 24 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 76 + "True": 24 test-flag4525: - percentage: 25 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 75 + "True": 25 test-flag4526: - percentage: 26 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 74 + "True": 26 test-flag4527: - percentage: 27 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 73 + "True": 27 test-flag4528: - percentage: 28 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 72 + "True": 28 test-flag4529: - percentage: 29 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 71 + "True": 29 test-flag4530: - percentage: 30 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 70 + "True": 30 test-flag4531: - percentage: 31 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 69 + "True": 31 test-flag4532: - percentage: 32 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 68 + "True": 32 test-flag4533: - percentage: 33 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 67 + "True": 33 test-flag4534: - percentage: 34 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 66 + "True": 34 test-flag4535: - percentage: 35 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 65 + "True": 35 test-flag4536: - percentage: 36 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 64 + "True": 36 test-flag4537: - percentage: 37 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 63 + "True": 37 test-flag4538: - percentage: 38 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 62 + "True": 38 test-flag4539: - percentage: 39 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 61 + "True": 39 test-flag4540: - percentage: 40 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 60 + "True": 40 test-flag4541: - percentage: 41 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 59 + "True": 41 test-flag4542: - percentage: 42 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 58 + "True": 42 test-flag4543: - percentage: 43 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 57 + "True": 43 test-flag4544: - percentage: 44 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 56 + "True": 44 test-flag4545: - percentage: 45 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 55 + "True": 45 test-flag4546: - percentage: 46 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 54 + "True": 46 test-flag4547: - percentage: 47 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 53 + "True": 47 test-flag4548: - percentage: 48 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 52 + "True": 48 test-flag4549: - percentage: 49 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 51 + "True": 49 test-flag4550: - percentage: 50 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 50 + "True": 50 test-flag4551: - percentage: 51 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 49 + "True": 51 test-flag4552: - percentage: 52 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 48 + "True": 52 test-flag4553: - percentage: 53 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 47 + "True": 53 test-flag4554: - percentage: 54 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 46 + "True": 54 test-flag4555: - percentage: 55 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 45 + "True": 55 test-flag4556: - percentage: 56 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 44 + "True": 56 test-flag4557: - percentage: 57 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 43 + "True": 57 test-flag4558: - percentage: 58 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 42 + "True": 58 test-flag4559: - percentage: 59 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 41 + "True": 59 test-flag4560: - percentage: 60 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 40 + "True": 60 test-flag4561: - percentage: 61 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 39 + "True": 61 test-flag4562: - percentage: 62 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 38 + "True": 62 test-flag4563: - percentage: 63 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 37 + "True": 63 test-flag4564: - percentage: 64 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 36 + "True": 64 test-flag4565: - percentage: 65 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 35 + "True": 65 test-flag4566: - percentage: 66 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 34 + "True": 66 test-flag4567: - percentage: 67 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 33 + "True": 67 test-flag4568: - percentage: 68 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 32 + "True": 68 test-flag4569: - percentage: 69 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 31 + "True": 69 test-flag4570: - percentage: 70 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 30 + "True": 70 test-flag4571: - percentage: 71 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 29 + "True": 71 test-flag4572: - percentage: 72 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 28 + "True": 72 test-flag4573: - percentage: 73 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 27 + "True": 73 test-flag4574: - percentage: 74 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 26 + "True": 74 test-flag4575: - percentage: 75 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 25 + "True": 75 test-flag4576: - percentage: 76 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 24 + "True": 76 test-flag4577: - percentage: 77 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 23 + "True": 77 test-flag4578: - percentage: 78 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 22 + "True": 78 test-flag4579: - percentage: 79 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 21 + "True": 79 test-flag4580: - percentage: 80 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 20 + "True": 80 test-flag4581: - percentage: 81 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 19 + "True": 81 test-flag4582: - percentage: 82 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 18 + "True": 82 test-flag4583: - percentage: 83 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 17 + "True": 83 test-flag4584: - percentage: 84 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 16 + "True": 84 test-flag4585: - percentage: 85 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 15 + "True": 85 test-flag4586: - percentage: 86 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 14 + "True": 86 test-flag4587: - percentage: 87 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 13 + "True": 87 test-flag4588: - percentage: 88 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 12 + "True": 88 test-flag4589: - percentage: 89 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 11 + "True": 89 test-flag4590: - percentage: 90 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 10 + "True": 90 test-flag4591: - percentage: 91 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 9 + "True": 91 test-flag4592: - percentage: 92 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 8 + "True": 92 test-flag4593: - percentage: 93 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 7 + "True": 93 test-flag4594: - percentage: 94 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 6 + "True": 94 test-flag4595: - percentage: 95 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 5 + "True": 95 test-flag4596: - percentage: 96 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 4 + "True": 96 test-flag4597: - percentage: 97 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 3 + "True": 97 test-flag4598: - percentage: 98 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 2 + "True": 98 test-flag4599: - percentage: 99 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 1 + "True": 99 test-flag4600: - percentage: 0 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 100 + "True": 0 test-flag4601: - percentage: 1 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 99 + "True": 1 test-flag4602: - percentage: 2 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 98 + "True": 2 test-flag4603: - percentage: 3 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 97 + "True": 3 test-flag4604: - percentage: 4 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 96 + "True": 4 test-flag4605: - percentage: 5 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 95 + "True": 5 test-flag4606: - percentage: 6 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 94 + "True": 6 test-flag4607: - percentage: 7 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 93 + "True": 7 test-flag4608: - percentage: 8 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 92 + "True": 8 test-flag4609: - percentage: 9 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 91 + "True": 9 test-flag4610: - percentage: 10 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 90 + "True": 10 test-flag4611: - percentage: 11 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 89 + "True": 11 test-flag4612: - percentage: 12 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 88 + "True": 12 test-flag4613: - percentage: 13 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 87 + "True": 13 test-flag4614: - percentage: 14 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 86 + "True": 14 test-flag4615: - percentage: 15 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 85 + "True": 15 test-flag4616: - percentage: 16 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 84 + "True": 16 test-flag4617: - percentage: 17 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 83 + "True": 17 test-flag4618: - percentage: 18 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 82 + "True": 18 test-flag4619: - percentage: 19 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 81 + "True": 19 test-flag4620: - percentage: 20 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 80 + "True": 20 test-flag4621: - percentage: 21 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 79 + "True": 21 test-flag4622: - percentage: 22 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 78 + "True": 22 test-flag4623: - percentage: 23 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 77 + "True": 23 test-flag4624: - percentage: 24 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 76 + "True": 24 test-flag4625: - percentage: 25 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 75 + "True": 25 test-flag4626: - percentage: 26 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 74 + "True": 26 test-flag4627: - percentage: 27 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 73 + "True": 27 test-flag4628: - percentage: 28 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 72 + "True": 28 test-flag4629: - percentage: 29 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 71 + "True": 29 test-flag4630: - percentage: 30 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 70 + "True": 30 test-flag4631: - percentage: 31 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 69 + "True": 31 test-flag4632: - percentage: 32 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 68 + "True": 32 test-flag4633: - percentage: 33 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 67 + "True": 33 test-flag4634: - percentage: 34 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 66 + "True": 34 test-flag4635: - percentage: 35 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 65 + "True": 35 test-flag4636: - percentage: 36 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 64 + "True": 36 test-flag4637: - percentage: 37 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 63 + "True": 37 test-flag4638: - percentage: 38 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 62 + "True": 38 test-flag4639: - percentage: 39 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 61 + "True": 39 test-flag4640: - percentage: 40 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 60 + "True": 40 test-flag4641: - percentage: 41 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 59 + "True": 41 test-flag4642: - percentage: 42 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 58 + "True": 42 test-flag4643: - percentage: 43 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 57 + "True": 43 test-flag4644: - percentage: 44 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 56 + "True": 44 test-flag4645: - percentage: 45 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 55 + "True": 45 test-flag4646: - percentage: 46 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 54 + "True": 46 test-flag4647: - percentage: 47 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 53 + "True": 47 test-flag4648: - percentage: 48 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 52 + "True": 48 test-flag4649: - percentage: 49 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 51 + "True": 49 test-flag4650: - percentage: 50 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 50 + "True": 50 test-flag4651: - percentage: 51 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 49 + "True": 51 test-flag4652: - percentage: 52 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 48 + "True": 52 test-flag4653: - percentage: 53 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 47 + "True": 53 test-flag4654: - percentage: 54 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 46 + "True": 54 test-flag4655: - percentage: 55 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 45 + "True": 55 test-flag4656: - percentage: 56 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 44 + "True": 56 test-flag4657: - percentage: 57 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 43 + "True": 57 test-flag4658: - percentage: 58 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 42 + "True": 58 test-flag4659: - percentage: 59 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 41 + "True": 59 test-flag4660: - percentage: 60 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 40 + "True": 60 test-flag4661: - percentage: 61 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 39 + "True": 61 test-flag4662: - percentage: 62 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 38 + "True": 62 test-flag4663: - percentage: 63 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 37 + "True": 63 test-flag4664: - percentage: 64 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 36 + "True": 64 test-flag4665: - percentage: 65 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 35 + "True": 65 test-flag4666: - percentage: 66 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 34 + "True": 66 test-flag4667: - percentage: 67 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 33 + "True": 67 test-flag4668: - percentage: 68 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 32 + "True": 68 test-flag4669: - percentage: 69 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 31 + "True": 69 test-flag4670: - percentage: 70 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 30 + "True": 70 test-flag4671: - percentage: 71 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 29 + "True": 71 test-flag4672: - percentage: 72 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 28 + "True": 72 test-flag4673: - percentage: 73 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 27 + "True": 73 test-flag4674: - percentage: 74 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 26 + "True": 74 test-flag4675: - percentage: 75 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 25 + "True": 75 test-flag4676: - percentage: 76 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 24 + "True": 76 test-flag4677: - percentage: 77 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 23 + "True": 77 test-flag4678: - percentage: 78 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 22 + "True": 78 test-flag4679: - percentage: 79 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 21 + "True": 79 test-flag4680: - percentage: 80 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 20 + "True": 80 test-flag4681: - percentage: 81 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 19 + "True": 81 test-flag4682: - percentage: 82 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 18 + "True": 82 test-flag4683: - percentage: 83 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 17 + "True": 83 test-flag4684: - percentage: 84 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 16 + "True": 84 test-flag4685: - percentage: 85 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 15 + "True": 85 test-flag4686: - percentage: 86 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 14 + "True": 86 test-flag4687: - percentage: 87 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 13 + "True": 87 test-flag4688: - percentage: 88 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 12 + "True": 88 test-flag4689: - percentage: 89 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 11 + "True": 89 test-flag4690: - percentage: 90 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 10 + "True": 90 test-flag4691: - percentage: 91 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 9 + "True": 91 test-flag4692: - percentage: 92 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 8 + "True": 92 test-flag4693: - percentage: 93 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 7 + "True": 93 test-flag4694: - percentage: 94 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 6 + "True": 94 test-flag4695: - percentage: 95 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 5 + "True": 95 test-flag4696: - percentage: 96 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 4 + "True": 96 test-flag4697: - percentage: 97 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 3 + "True": 97 test-flag4698: - percentage: 98 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 2 + "True": 98 test-flag4699: - percentage: 99 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 1 + "True": 99 test-flag4700: - percentage: 0 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 100 + "True": 0 test-flag4701: - percentage: 1 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 99 + "True": 1 test-flag4702: - percentage: 2 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 98 + "True": 2 test-flag4703: - percentage: 3 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 97 + "True": 3 test-flag4704: - percentage: 4 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 96 + "True": 4 test-flag4705: - percentage: 5 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 95 + "True": 5 test-flag4706: - percentage: 6 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 94 + "True": 6 test-flag4707: - percentage: 7 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 93 + "True": 7 test-flag4708: - percentage: 8 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 92 + "True": 8 test-flag4709: - percentage: 9 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 91 + "True": 9 test-flag4710: - percentage: 10 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 90 + "True": 10 test-flag4711: - percentage: 11 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 89 + "True": 11 test-flag4712: - percentage: 12 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 88 + "True": 12 test-flag4713: - percentage: 13 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 87 + "True": 13 test-flag4714: - percentage: 14 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 86 + "True": 14 test-flag4715: - percentage: 15 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 85 + "True": 15 test-flag4716: - percentage: 16 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 84 + "True": 16 test-flag4717: - percentage: 17 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 83 + "True": 17 test-flag4718: - percentage: 18 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 82 + "True": 18 test-flag4719: - percentage: 19 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 81 + "True": 19 test-flag4720: - percentage: 20 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 80 + "True": 20 test-flag4721: - percentage: 21 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 79 + "True": 21 test-flag4722: - percentage: 22 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 78 + "True": 22 test-flag4723: - percentage: 23 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 77 + "True": 23 test-flag4724: - percentage: 24 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 76 + "True": 24 test-flag4725: - percentage: 25 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 75 + "True": 25 test-flag4726: - percentage: 26 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 74 + "True": 26 test-flag4727: - percentage: 27 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 73 + "True": 27 test-flag4728: - percentage: 28 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 72 + "True": 28 test-flag4729: - percentage: 29 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 71 + "True": 29 test-flag4730: - percentage: 30 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 70 + "True": 30 test-flag4731: - percentage: 31 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 69 + "True": 31 test-flag4732: - percentage: 32 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 68 + "True": 32 test-flag4733: - percentage: 33 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 67 + "True": 33 test-flag4734: - percentage: 34 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 66 + "True": 34 test-flag4735: - percentage: 35 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 65 + "True": 35 test-flag4736: - percentage: 36 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 64 + "True": 36 test-flag4737: - percentage: 37 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 63 + "True": 37 test-flag4738: - percentage: 38 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 62 + "True": 38 test-flag4739: - percentage: 39 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 61 + "True": 39 test-flag4740: - percentage: 40 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 60 + "True": 40 test-flag4741: - percentage: 41 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 59 + "True": 41 test-flag4742: - percentage: 42 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 58 + "True": 42 test-flag4743: - percentage: 43 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 57 + "True": 43 test-flag4744: - percentage: 44 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 56 + "True": 44 test-flag4745: - percentage: 45 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 55 + "True": 45 test-flag4746: - percentage: 46 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 54 + "True": 46 test-flag4747: - percentage: 47 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 53 + "True": 47 test-flag4748: - percentage: 48 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 52 + "True": 48 test-flag4749: - percentage: 49 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 51 + "True": 49 test-flag4750: - percentage: 50 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 50 + "True": 50 test-flag4751: - percentage: 51 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 49 + "True": 51 test-flag4752: - percentage: 52 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 48 + "True": 52 test-flag4753: - percentage: 53 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 47 + "True": 53 test-flag4754: - percentage: 54 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 46 + "True": 54 test-flag4755: - percentage: 55 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 45 + "True": 55 test-flag4756: - percentage: 56 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 44 + "True": 56 test-flag4757: - percentage: 57 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 43 + "True": 57 test-flag4758: - percentage: 58 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 42 + "True": 58 test-flag4759: - percentage: 59 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 41 + "True": 59 test-flag4760: - percentage: 60 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 40 + "True": 60 test-flag4761: - percentage: 61 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 39 + "True": 61 test-flag4762: - percentage: 62 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 38 + "True": 62 test-flag4763: - percentage: 63 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 37 + "True": 63 test-flag4764: - percentage: 64 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 36 + "True": 64 test-flag4765: - percentage: 65 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 35 + "True": 65 test-flag4766: - percentage: 66 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 34 + "True": 66 test-flag4767: - percentage: 67 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 33 + "True": 67 test-flag4768: - percentage: 68 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 32 + "True": 68 test-flag4769: - percentage: 69 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 31 + "True": 69 test-flag4770: - percentage: 70 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 30 + "True": 70 test-flag4771: - percentage: 71 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 29 + "True": 71 test-flag4772: - percentage: 72 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 28 + "True": 72 test-flag4773: - percentage: 73 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 27 + "True": 73 test-flag4774: - percentage: 74 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 26 + "True": 74 test-flag4775: - percentage: 75 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 25 + "True": 75 test-flag4776: - percentage: 76 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 24 + "True": 76 test-flag4777: - percentage: 77 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 23 + "True": 77 test-flag4778: - percentage: 78 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 22 + "True": 78 test-flag4779: - percentage: 79 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 21 + "True": 79 test-flag4780: - percentage: 80 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 20 + "True": 80 test-flag4781: - percentage: 81 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 19 + "True": 81 test-flag4782: - percentage: 82 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 18 + "True": 82 test-flag4783: - percentage: 83 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 17 + "True": 83 test-flag4784: - percentage: 84 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 16 + "True": 84 test-flag4785: - percentage: 85 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 15 + "True": 85 test-flag4786: - percentage: 86 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 14 + "True": 86 test-flag4787: - percentage: 87 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 13 + "True": 87 test-flag4788: - percentage: 88 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 12 + "True": 88 test-flag4789: - percentage: 89 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 11 + "True": 89 test-flag4790: - percentage: 90 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 10 + "True": 90 test-flag4791: - percentage: 91 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 9 + "True": 91 test-flag4792: - percentage: 92 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 8 + "True": 92 test-flag4793: - percentage: 93 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 7 + "True": 93 test-flag4794: - percentage: 94 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 6 + "True": 94 test-flag4795: - percentage: 95 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 5 + "True": 95 test-flag4796: - percentage: 96 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 4 + "True": 96 test-flag4797: - percentage: 97 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 3 + "True": 97 test-flag4798: - percentage: 98 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 2 + "True": 98 test-flag4799: - percentage: 99 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 1 + "True": 99 test-flag4800: - percentage: 0 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 100 + "True": 0 test-flag4801: - percentage: 1 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 99 + "True": 1 test-flag4802: - percentage: 2 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 98 + "True": 2 test-flag4803: - percentage: 3 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 97 + "True": 3 test-flag4804: - percentage: 4 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 96 + "True": 4 test-flag4805: - percentage: 5 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 95 + "True": 5 test-flag4806: - percentage: 6 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 94 + "True": 6 test-flag4807: - percentage: 7 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 93 + "True": 7 test-flag4808: - percentage: 8 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 92 + "True": 8 test-flag4809: - percentage: 9 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 91 + "True": 9 test-flag4810: - percentage: 10 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 90 + "True": 10 test-flag4811: - percentage: 11 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 89 + "True": 11 test-flag4812: - percentage: 12 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 88 + "True": 12 test-flag4813: - percentage: 13 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 87 + "True": 13 test-flag4814: - percentage: 14 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 86 + "True": 14 test-flag4815: - percentage: 15 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 85 + "True": 15 test-flag4816: - percentage: 16 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 84 + "True": 16 test-flag4817: - percentage: 17 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 83 + "True": 17 test-flag4818: - percentage: 18 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 82 + "True": 18 test-flag4819: - percentage: 19 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 81 + "True": 19 test-flag4820: - percentage: 20 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 80 + "True": 20 test-flag4821: - percentage: 21 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 79 + "True": 21 test-flag4822: - percentage: 22 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 78 + "True": 22 test-flag4823: - percentage: 23 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 77 + "True": 23 test-flag4824: - percentage: 24 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 76 + "True": 24 test-flag4825: - percentage: 25 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 75 + "True": 25 test-flag4826: - percentage: 26 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 74 + "True": 26 test-flag4827: - percentage: 27 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 73 + "True": 27 test-flag4828: - percentage: 28 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 72 + "True": 28 test-flag4829: - percentage: 29 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 71 + "True": 29 test-flag4830: - percentage: 30 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 70 + "True": 30 test-flag4831: - percentage: 31 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 69 + "True": 31 test-flag4832: - percentage: 32 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 68 + "True": 32 test-flag4833: - percentage: 33 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 67 + "True": 33 test-flag4834: - percentage: 34 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 66 + "True": 34 test-flag4835: - percentage: 35 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 65 + "True": 35 test-flag4836: - percentage: 36 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 64 + "True": 36 test-flag4837: - percentage: 37 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 63 + "True": 37 test-flag4838: - percentage: 38 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 62 + "True": 38 test-flag4839: - percentage: 39 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 61 + "True": 39 test-flag4840: - percentage: 40 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 60 + "True": 40 test-flag4841: - percentage: 41 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 59 + "True": 41 test-flag4842: - percentage: 42 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 58 + "True": 42 test-flag4843: - percentage: 43 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 57 + "True": 43 test-flag4844: - percentage: 44 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 56 + "True": 44 test-flag4845: - percentage: 45 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 55 + "True": 45 test-flag4846: - percentage: 46 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 54 + "True": 46 test-flag4847: - percentage: 47 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 53 + "True": 47 test-flag4848: - percentage: 48 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 52 + "True": 48 test-flag4849: - percentage: 49 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 51 + "True": 49 test-flag4850: - percentage: 50 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 50 + "True": 50 test-flag4851: - percentage: 51 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 49 + "True": 51 test-flag4852: - percentage: 52 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 48 + "True": 52 test-flag4853: - percentage: 53 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 47 + "True": 53 test-flag4854: - percentage: 54 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 46 + "True": 54 test-flag4855: - percentage: 55 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 45 + "True": 55 test-flag4856: - percentage: 56 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 44 + "True": 56 test-flag4857: - percentage: 57 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 43 + "True": 57 test-flag4858: - percentage: 58 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 42 + "True": 58 test-flag4859: - percentage: 59 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 41 + "True": 59 test-flag4860: - percentage: 60 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 40 + "True": 60 test-flag4861: - percentage: 61 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 39 + "True": 61 test-flag4862: - percentage: 62 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 38 + "True": 62 test-flag4863: - percentage: 63 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 37 + "True": 63 test-flag4864: - percentage: 64 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 36 + "True": 64 test-flag4865: - percentage: 65 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 35 + "True": 65 test-flag4866: - percentage: 66 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 34 + "True": 66 test-flag4867: - percentage: 67 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 33 + "True": 67 test-flag4868: - percentage: 68 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 32 + "True": 68 test-flag4869: - percentage: 69 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 31 + "True": 69 test-flag4870: - percentage: 70 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 30 + "True": 70 test-flag4871: - percentage: 71 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 29 + "True": 71 test-flag4872: - percentage: 72 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 28 + "True": 72 test-flag4873: - percentage: 73 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 27 + "True": 73 test-flag4874: - percentage: 74 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 26 + "True": 74 test-flag4875: - percentage: 75 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 25 + "True": 75 test-flag4876: - percentage: 76 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 24 + "True": 76 test-flag4877: - percentage: 77 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 23 + "True": 77 test-flag4878: - percentage: 78 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 22 + "True": 78 test-flag4879: - percentage: 79 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 21 + "True": 79 test-flag4880: - percentage: 80 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 20 + "True": 80 test-flag4881: - percentage: 81 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 19 + "True": 81 test-flag4882: - percentage: 82 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 18 + "True": 82 test-flag4883: - percentage: 83 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 17 + "True": 83 test-flag4884: - percentage: 84 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 16 + "True": 84 test-flag4885: - percentage: 85 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 15 + "True": 85 test-flag4886: - percentage: 86 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 14 + "True": 86 test-flag4887: - percentage: 87 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 13 + "True": 87 test-flag4888: - percentage: 88 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 12 + "True": 88 test-flag4889: - percentage: 89 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 11 + "True": 89 test-flag4890: - percentage: 90 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 10 + "True": 90 test-flag4891: - percentage: 91 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 9 + "True": 91 test-flag4892: - percentage: 92 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 8 + "True": 92 test-flag4893: - percentage: 93 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 7 + "True": 93 test-flag4894: - percentage: 94 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 6 + "True": 94 test-flag4895: - percentage: 95 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 5 + "True": 95 test-flag4896: - percentage: 96 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 4 + "True": 96 test-flag4897: - percentage: 97 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 3 + "True": 97 test-flag4898: - percentage: 98 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 2 + "True": 98 test-flag4899: - percentage: 99 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 1 + "True": 99 test-flag4900: - percentage: 0 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 100 + "True": 0 test-flag4901: - percentage: 1 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 99 + "True": 1 test-flag4902: - percentage: 2 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 98 + "True": 2 test-flag4903: - percentage: 3 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 97 + "True": 3 test-flag4904: - percentage: 4 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 96 + "True": 4 test-flag4905: - percentage: 5 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 95 + "True": 5 test-flag4906: - percentage: 6 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 94 + "True": 6 test-flag4907: - percentage: 7 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 93 + "True": 7 test-flag4908: - percentage: 8 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 92 + "True": 8 test-flag4909: - percentage: 9 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 91 + "True": 9 test-flag4910: - percentage: 10 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 90 + "True": 10 test-flag4911: - percentage: 11 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 89 + "True": 11 test-flag4912: - percentage: 12 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 88 + "True": 12 test-flag4913: - percentage: 13 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 87 + "True": 13 test-flag4914: - percentage: 14 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 86 + "True": 14 test-flag4915: - percentage: 15 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 85 + "True": 15 test-flag4916: - percentage: 16 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 84 + "True": 16 test-flag4917: - percentage: 17 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 83 + "True": 17 test-flag4918: - percentage: 18 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 82 + "True": 18 test-flag4919: - percentage: 19 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 81 + "True": 19 test-flag4920: - percentage: 20 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 80 + "True": 20 test-flag4921: - percentage: 21 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 79 + "True": 21 test-flag4922: - percentage: 22 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 78 + "True": 22 test-flag4923: - percentage: 23 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 77 + "True": 23 test-flag4924: - percentage: 24 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 76 + "True": 24 test-flag4925: - percentage: 25 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 75 + "True": 25 test-flag4926: - percentage: 26 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 74 + "True": 26 test-flag4927: - percentage: 27 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 73 + "True": 27 test-flag4928: - percentage: 28 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 72 + "True": 28 test-flag4929: - percentage: 29 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 71 + "True": 29 test-flag4930: - percentage: 30 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 70 + "True": 30 test-flag4931: - percentage: 31 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 69 + "True": 31 test-flag4932: - percentage: 32 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 68 + "True": 32 test-flag4933: - percentage: 33 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 67 + "True": 33 test-flag4934: - percentage: 34 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 66 + "True": 34 test-flag4935: - percentage: 35 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 65 + "True": 35 test-flag4936: - percentage: 36 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 64 + "True": 36 test-flag4937: - percentage: 37 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 63 + "True": 37 test-flag4938: - percentage: 38 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 62 + "True": 38 test-flag4939: - percentage: 39 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 61 + "True": 39 test-flag4940: - percentage: 40 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 60 + "True": 40 test-flag4941: - percentage: 41 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 59 + "True": 41 test-flag4942: - percentage: 42 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 58 + "True": 42 test-flag4943: - percentage: 43 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 57 + "True": 43 test-flag4944: - percentage: 44 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 56 + "True": 44 test-flag4945: - percentage: 45 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 55 + "True": 45 test-flag4946: - percentage: 46 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 54 + "True": 46 test-flag4947: - percentage: 47 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 53 + "True": 47 test-flag4948: - percentage: 48 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 52 + "True": 48 test-flag4949: - percentage: 49 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 51 + "True": 49 test-flag4950: - percentage: 50 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 50 + "True": 50 test-flag4951: - percentage: 51 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 49 + "True": 51 test-flag4952: - percentage: 52 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 48 + "True": 52 test-flag4953: - percentage: 53 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 47 + "True": 53 test-flag4954: - percentage: 54 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 46 + "True": 54 test-flag4955: - percentage: 55 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 45 + "True": 55 test-flag4956: - percentage: 56 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 44 + "True": 56 test-flag4957: - percentage: 57 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 43 + "True": 57 test-flag4958: - percentage: 58 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 42 + "True": 58 test-flag4959: - percentage: 59 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 41 + "True": 59 test-flag4960: - percentage: 60 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 40 + "True": 60 test-flag4961: - percentage: 61 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 39 + "True": 61 test-flag4962: - percentage: 62 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 38 + "True": 62 test-flag4963: - percentage: 63 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 37 + "True": 63 test-flag4964: - percentage: 64 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 36 + "True": 64 test-flag4965: - percentage: 65 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 35 + "True": 65 test-flag4966: - percentage: 66 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 34 + "True": 66 test-flag4967: - percentage: 67 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 33 + "True": 67 test-flag4968: - percentage: 68 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 32 + "True": 68 test-flag4969: - percentage: 69 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 31 + "True": 69 test-flag4970: - percentage: 70 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 30 + "True": 70 test-flag4971: - percentage: 71 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 29 + "True": 71 test-flag4972: - percentage: 72 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 28 + "True": 72 test-flag4973: - percentage: 73 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 27 + "True": 73 test-flag4974: - percentage: 74 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 26 + "True": 74 test-flag4975: - percentage: 75 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 25 + "True": 75 test-flag4976: - percentage: 76 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 24 + "True": 76 test-flag4977: - percentage: 77 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 23 + "True": 77 test-flag4978: - percentage: 78 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 22 + "True": 78 test-flag4979: - percentage: 79 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 21 + "True": 79 test-flag4980: - percentage: 80 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 20 + "True": 80 test-flag4981: - percentage: 81 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 19 + "True": 81 test-flag4982: - percentage: 82 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 18 + "True": 82 test-flag4983: - percentage: 83 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 17 + "True": 83 test-flag4984: - percentage: 84 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 16 + "True": 84 test-flag4985: - percentage: 85 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 15 + "True": 85 test-flag4986: - percentage: 86 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 14 + "True": 86 test-flag4987: - percentage: 87 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 13 + "True": 87 test-flag4988: - percentage: 88 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 12 + "True": 88 test-flag4989: - percentage: 89 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 11 + "True": 89 test-flag4990: - percentage: 90 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 10 + "True": 90 test-flag4991: - percentage: 91 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 9 + "True": 91 test-flag4992: - percentage: 92 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 8 + "True": 92 test-flag4993: - percentage: 93 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 7 + "True": 93 test-flag4994: - percentage: 94 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 6 + "True": 94 test-flag4995: - percentage: 95 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 5 + "True": 95 test-flag4996: - percentage: 96 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 4 + "True": 96 test-flag4997: - percentage: 97 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 3 + "True": 97 test-flag4998: - percentage: 98 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 2 + "True": 98 test-flag4999: - percentage: 99 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 1 + "True": 99 test-flag5000: - percentage: 0 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 100 + "True": 0 test-flag5001: - percentage: 1 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 99 + "True": 1 test-flag5002: - percentage: 2 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 98 + "True": 2 test-flag5003: - percentage: 3 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 97 + "True": 3 test-flag5004: - percentage: 4 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 96 + "True": 4 test-flag5005: - percentage: 5 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 95 + "True": 5 test-flag5006: - percentage: 6 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 94 + "True": 6 test-flag5007: - percentage: 7 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 93 + "True": 7 test-flag5008: - percentage: 8 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 92 + "True": 8 test-flag5009: - percentage: 9 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 91 + "True": 9 test-flag5010: - percentage: 10 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 90 + "True": 10 test-flag5011: - percentage: 11 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 89 + "True": 11 test-flag5012: - percentage: 12 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 88 + "True": 12 test-flag5013: - percentage: 13 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 87 + "True": 13 test-flag5014: - percentage: 14 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 86 + "True": 14 test-flag5015: - percentage: 15 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 85 + "True": 15 test-flag5016: - percentage: 16 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 84 + "True": 16 test-flag5017: - percentage: 17 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 83 + "True": 17 test-flag5018: - percentage: 18 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 82 + "True": 18 test-flag5019: - percentage: 19 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 81 + "True": 19 test-flag5020: - percentage: 20 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 80 + "True": 20 test-flag5021: - percentage: 21 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 79 + "True": 21 test-flag5022: - percentage: 22 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 78 + "True": 22 test-flag5023: - percentage: 23 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 77 + "True": 23 test-flag5024: - percentage: 24 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 76 + "True": 24 test-flag5025: - percentage: 25 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 75 + "True": 25 test-flag5026: - percentage: 26 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 74 + "True": 26 test-flag5027: - percentage: 27 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 73 + "True": 27 test-flag5028: - percentage: 28 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 72 + "True": 28 test-flag5029: - percentage: 29 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 71 + "True": 29 test-flag5030: - percentage: 30 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 70 + "True": 30 test-flag5031: - percentage: 31 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 69 + "True": 31 test-flag5032: - percentage: 32 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 68 + "True": 32 test-flag5033: - percentage: 33 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 67 + "True": 33 test-flag5034: - percentage: 34 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 66 + "True": 34 test-flag5035: - percentage: 35 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 65 + "True": 35 test-flag5036: - percentage: 36 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 64 + "True": 36 test-flag5037: - percentage: 37 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 63 + "True": 37 test-flag5038: - percentage: 38 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 62 + "True": 38 test-flag5039: - percentage: 39 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 61 + "True": 39 test-flag5040: - percentage: 40 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 60 + "True": 40 test-flag5041: - percentage: 41 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 59 + "True": 41 test-flag5042: - percentage: 42 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 58 + "True": 42 test-flag5043: - percentage: 43 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 57 + "True": 43 test-flag5044: - percentage: 44 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 56 + "True": 44 test-flag5045: - percentage: 45 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 55 + "True": 45 test-flag5046: - percentage: 46 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 54 + "True": 46 test-flag5047: - percentage: 47 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 53 + "True": 47 test-flag5048: - percentage: 48 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 52 + "True": 48 test-flag5049: - percentage: 49 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 51 + "True": 49 test-flag5050: - percentage: 50 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 50 + "True": 50 test-flag5051: - percentage: 51 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 49 + "True": 51 test-flag5052: - percentage: 52 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 48 + "True": 52 test-flag5053: - percentage: 53 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 47 + "True": 53 test-flag5054: - percentage: 54 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 46 + "True": 54 test-flag5055: - percentage: 55 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 45 + "True": 55 test-flag5056: - percentage: 56 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 44 + "True": 56 test-flag5057: - percentage: 57 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 43 + "True": 57 test-flag5058: - percentage: 58 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 42 + "True": 58 test-flag5059: - percentage: 59 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 41 + "True": 59 test-flag5060: - percentage: 60 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 40 + "True": 60 test-flag5061: - percentage: 61 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 39 + "True": 61 test-flag5062: - percentage: 62 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 38 + "True": 62 test-flag5063: - percentage: 63 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 37 + "True": 63 test-flag5064: - percentage: 64 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 36 + "True": 64 test-flag5065: - percentage: 65 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 35 + "True": 65 test-flag5066: - percentage: 66 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 34 + "True": 66 test-flag5067: - percentage: 67 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 33 + "True": 67 test-flag5068: - percentage: 68 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 32 + "True": 68 test-flag5069: - percentage: 69 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 31 + "True": 69 test-flag5070: - percentage: 70 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 30 + "True": 70 test-flag5071: - percentage: 71 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 29 + "True": 71 test-flag5072: - percentage: 72 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 28 + "True": 72 test-flag5073: - percentage: 73 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 27 + "True": 73 test-flag5074: - percentage: 74 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 26 + "True": 74 test-flag5075: - percentage: 75 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 25 + "True": 75 test-flag5076: - percentage: 76 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 24 + "True": 76 test-flag5077: - percentage: 77 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 23 + "True": 77 test-flag5078: - percentage: 78 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 22 + "True": 78 test-flag5079: - percentage: 79 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 21 + "True": 79 test-flag5080: - percentage: 80 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 20 + "True": 80 test-flag5081: - percentage: 81 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 19 + "True": 81 test-flag5082: - percentage: 82 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 18 + "True": 82 test-flag5083: - percentage: 83 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 17 + "True": 83 test-flag5084: - percentage: 84 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 16 + "True": 84 test-flag5085: - percentage: 85 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 15 + "True": 85 test-flag5086: - percentage: 86 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 14 + "True": 86 test-flag5087: - percentage: 87 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 13 + "True": 87 test-flag5088: - percentage: 88 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 12 + "True": 88 test-flag5089: - percentage: 89 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 11 + "True": 89 test-flag5090: - percentage: 90 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 10 + "True": 90 test-flag5091: - percentage: 91 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 9 + "True": 91 test-flag5092: - percentage: 92 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 8 + "True": 92 test-flag5093: - percentage: 93 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 7 + "True": 93 test-flag5094: - percentage: 94 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 6 + "True": 94 test-flag5095: - percentage: 95 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 5 + "True": 95 test-flag5096: - percentage: 96 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 4 + "True": 96 test-flag5097: - percentage: 97 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 3 + "True": 97 test-flag5098: - percentage: 98 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 2 + "True": 98 test-flag5099: - percentage: 99 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 1 + "True": 99 test-flag5100: - percentage: 0 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 100 + "True": 0 test-flag5101: - percentage: 1 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 99 + "True": 1 test-flag5102: - percentage: 2 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 98 + "True": 2 test-flag5103: - percentage: 3 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 97 + "True": 3 test-flag5104: - percentage: 4 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 96 + "True": 4 test-flag5105: - percentage: 5 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 95 + "True": 5 test-flag5106: - percentage: 6 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 94 + "True": 6 test-flag5107: - percentage: 7 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 93 + "True": 7 test-flag5108: - percentage: 8 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 92 + "True": 8 test-flag5109: - percentage: 9 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 91 + "True": 9 test-flag5110: - percentage: 10 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 90 + "True": 10 test-flag5111: - percentage: 11 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 89 + "True": 11 test-flag5112: - percentage: 12 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 88 + "True": 12 test-flag5113: - percentage: 13 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 87 + "True": 13 test-flag5114: - percentage: 14 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 86 + "True": 14 test-flag5115: - percentage: 15 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 85 + "True": 15 test-flag5116: - percentage: 16 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 84 + "True": 16 test-flag5117: - percentage: 17 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 83 + "True": 17 test-flag5118: - percentage: 18 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 82 + "True": 18 test-flag5119: - percentage: 19 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 81 + "True": 19 test-flag5120: - percentage: 20 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 80 + "True": 20 test-flag5121: - percentage: 21 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 79 + "True": 21 test-flag5122: - percentage: 22 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 78 + "True": 22 test-flag5123: - percentage: 23 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 77 + "True": 23 test-flag5124: - percentage: 24 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 76 + "True": 24 test-flag5125: - percentage: 25 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 75 + "True": 25 test-flag5126: - percentage: 26 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 74 + "True": 26 test-flag5127: - percentage: 27 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 73 + "True": 27 test-flag5128: - percentage: 28 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 72 + "True": 28 test-flag5129: - percentage: 29 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 71 + "True": 29 test-flag5130: - percentage: 30 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 70 + "True": 30 test-flag5131: - percentage: 31 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 69 + "True": 31 test-flag5132: - percentage: 32 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 68 + "True": 32 test-flag5133: - percentage: 33 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 67 + "True": 33 test-flag5134: - percentage: 34 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 66 + "True": 34 test-flag5135: - percentage: 35 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 65 + "True": 35 test-flag5136: - percentage: 36 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 64 + "True": 36 test-flag5137: - percentage: 37 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 63 + "True": 37 test-flag5138: - percentage: 38 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 62 + "True": 38 test-flag5139: - percentage: 39 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 61 + "True": 39 test-flag5140: - percentage: 40 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 60 + "True": 40 test-flag5141: - percentage: 41 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 59 + "True": 41 test-flag5142: - percentage: 42 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 58 + "True": 42 test-flag5143: - percentage: 43 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 57 + "True": 43 test-flag5144: - percentage: 44 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 56 + "True": 44 test-flag5145: - percentage: 45 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 55 + "True": 45 test-flag5146: - percentage: 46 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 54 + "True": 46 test-flag5147: - percentage: 47 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 53 + "True": 47 test-flag5148: - percentage: 48 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 52 + "True": 48 test-flag5149: - percentage: 49 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 51 + "True": 49 test-flag5150: - percentage: 50 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 50 + "True": 50 test-flag5151: - percentage: 51 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 49 + "True": 51 test-flag5152: - percentage: 52 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 48 + "True": 52 test-flag5153: - percentage: 53 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 47 + "True": 53 test-flag5154: - percentage: 54 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 46 + "True": 54 test-flag5155: - percentage: 55 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 45 + "True": 55 test-flag5156: - percentage: 56 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 44 + "True": 56 test-flag5157: - percentage: 57 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 43 + "True": 57 test-flag5158: - percentage: 58 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 42 + "True": 58 test-flag5159: - percentage: 59 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 41 + "True": 59 test-flag5160: - percentage: 60 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 40 + "True": 60 test-flag5161: - percentage: 61 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 39 + "True": 61 test-flag5162: - percentage: 62 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 38 + "True": 62 test-flag5163: - percentage: 63 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 37 + "True": 63 test-flag5164: - percentage: 64 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 36 + "True": 64 test-flag5165: - percentage: 65 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 35 + "True": 65 test-flag5166: - percentage: 66 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 34 + "True": 66 test-flag5167: - percentage: 67 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 33 + "True": 67 test-flag5168: - percentage: 68 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 32 + "True": 68 test-flag5169: - percentage: 69 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 31 + "True": 69 test-flag5170: - percentage: 70 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 30 + "True": 70 test-flag5171: - percentage: 71 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 29 + "True": 71 test-flag5172: - percentage: 72 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 28 + "True": 72 test-flag5173: - percentage: 73 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 27 + "True": 73 test-flag5174: - percentage: 74 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 26 + "True": 74 test-flag5175: - percentage: 75 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 25 + "True": 75 test-flag5176: - percentage: 76 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 24 + "True": 76 test-flag5177: - percentage: 77 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 23 + "True": 77 test-flag5178: - percentage: 78 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 22 + "True": 78 test-flag5179: - percentage: 79 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 21 + "True": 79 test-flag5180: - percentage: 80 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 20 + "True": 80 test-flag5181: - percentage: 81 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 19 + "True": 81 test-flag5182: - percentage: 82 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 18 + "True": 82 test-flag5183: - percentage: 83 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 17 + "True": 83 test-flag5184: - percentage: 84 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 16 + "True": 84 test-flag5185: - percentage: 85 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 15 + "True": 85 test-flag5186: - percentage: 86 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 14 + "True": 86 test-flag5187: - percentage: 87 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 13 + "True": 87 test-flag5188: - percentage: 88 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 12 + "True": 88 test-flag5189: - percentage: 89 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 11 + "True": 89 test-flag5190: - percentage: 90 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 10 + "True": 90 test-flag5191: - percentage: 91 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 9 + "True": 91 test-flag5192: - percentage: 92 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 8 + "True": 92 test-flag5193: - percentage: 93 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 7 + "True": 93 test-flag5194: - percentage: 94 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 6 + "True": 94 test-flag5195: - percentage: 95 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 5 + "True": 95 test-flag5196: - percentage: 96 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 4 + "True": 96 test-flag5197: - percentage: 97 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 3 + "True": 97 test-flag5198: - percentage: 98 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 2 + "True": 98 test-flag5199: - percentage: 99 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 1 + "True": 99 test-flag5200: - percentage: 0 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 100 + "True": 0 test-flag5201: - percentage: 1 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 99 + "True": 1 test-flag5202: - percentage: 2 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 98 + "True": 2 test-flag5203: - percentage: 3 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 97 + "True": 3 test-flag5204: - percentage: 4 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 96 + "True": 4 test-flag5205: - percentage: 5 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 95 + "True": 5 test-flag5206: - percentage: 6 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 94 + "True": 6 test-flag5207: - percentage: 7 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 93 + "True": 7 test-flag5208: - percentage: 8 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 92 + "True": 8 test-flag5209: - percentage: 9 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 91 + "True": 9 test-flag5210: - percentage: 10 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 90 + "True": 10 test-flag5211: - percentage: 11 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 89 + "True": 11 test-flag5212: - percentage: 12 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 88 + "True": 12 test-flag5213: - percentage: 13 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 87 + "True": 13 test-flag5214: - percentage: 14 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 86 + "True": 14 test-flag5215: - percentage: 15 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 85 + "True": 15 test-flag5216: - percentage: 16 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 84 + "True": 16 test-flag5217: - percentage: 17 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 83 + "True": 17 test-flag5218: - percentage: 18 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 82 + "True": 18 test-flag5219: - percentage: 19 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 81 + "True": 19 test-flag5220: - percentage: 20 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 80 + "True": 20 test-flag5221: - percentage: 21 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 79 + "True": 21 test-flag5222: - percentage: 22 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 78 + "True": 22 test-flag5223: - percentage: 23 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 77 + "True": 23 test-flag5224: - percentage: 24 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 76 + "True": 24 test-flag5225: - percentage: 25 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 75 + "True": 25 test-flag5226: - percentage: 26 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 74 + "True": 26 test-flag5227: - percentage: 27 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 73 + "True": 27 test-flag5228: - percentage: 28 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 72 + "True": 28 test-flag5229: - percentage: 29 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 71 + "True": 29 test-flag5230: - percentage: 30 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 70 + "True": 30 test-flag5231: - percentage: 31 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 69 + "True": 31 test-flag5232: - percentage: 32 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 68 + "True": 32 test-flag5233: - percentage: 33 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 67 + "True": 33 test-flag5234: - percentage: 34 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 66 + "True": 34 test-flag5235: - percentage: 35 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 65 + "True": 35 test-flag5236: - percentage: 36 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 64 + "True": 36 test-flag5237: - percentage: 37 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 63 + "True": 37 test-flag5238: - percentage: 38 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 62 + "True": 38 test-flag5239: - percentage: 39 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 61 + "True": 39 test-flag5240: - percentage: 40 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 60 + "True": 40 test-flag5241: - percentage: 41 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 59 + "True": 41 test-flag5242: - percentage: 42 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 58 + "True": 42 test-flag5243: - percentage: 43 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 57 + "True": 43 test-flag5244: - percentage: 44 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 56 + "True": 44 test-flag5245: - percentage: 45 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 55 + "True": 45 test-flag5246: - percentage: 46 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 54 + "True": 46 test-flag5247: - percentage: 47 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 53 + "True": 47 test-flag5248: - percentage: 48 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 52 + "True": 48 test-flag5249: - percentage: 49 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 51 + "True": 49 test-flag5250: - percentage: 50 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 50 + "True": 50 test-flag5251: - percentage: 51 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 49 + "True": 51 test-flag5252: - percentage: 52 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 48 + "True": 52 test-flag5253: - percentage: 53 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 47 + "True": 53 test-flag5254: - percentage: 54 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 46 + "True": 54 test-flag5255: - percentage: 55 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 45 + "True": 55 test-flag5256: - percentage: 56 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 44 + "True": 56 test-flag5257: - percentage: 57 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 43 + "True": 57 test-flag5258: - percentage: 58 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 42 + "True": 58 test-flag5259: - percentage: 59 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 41 + "True": 59 test-flag5260: - percentage: 60 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 40 + "True": 60 test-flag5261: - percentage: 61 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 39 + "True": 61 test-flag5262: - percentage: 62 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 38 + "True": 62 test-flag5263: - percentage: 63 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 37 + "True": 63 test-flag5264: - percentage: 64 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 36 + "True": 64 test-flag5265: - percentage: 65 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 35 + "True": 65 test-flag5266: - percentage: 66 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 34 + "True": 66 test-flag5267: - percentage: 67 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 33 + "True": 67 test-flag5268: - percentage: 68 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 32 + "True": 68 test-flag5269: - percentage: 69 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 31 + "True": 69 test-flag5270: - percentage: 70 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 30 + "True": 70 test-flag5271: - percentage: 71 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 29 + "True": 71 test-flag5272: - percentage: 72 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 28 + "True": 72 test-flag5273: - percentage: 73 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 27 + "True": 73 test-flag5274: - percentage: 74 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 26 + "True": 74 test-flag5275: - percentage: 75 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 25 + "True": 75 test-flag5276: - percentage: 76 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 24 + "True": 76 test-flag5277: - percentage: 77 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 23 + "True": 77 test-flag5278: - percentage: 78 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 22 + "True": 78 test-flag5279: - percentage: 79 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 21 + "True": 79 test-flag5280: - percentage: 80 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 20 + "True": 80 test-flag5281: - percentage: 81 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 19 + "True": 81 test-flag5282: - percentage: 82 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 18 + "True": 82 test-flag5283: - percentage: 83 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 17 + "True": 83 test-flag5284: - percentage: 84 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 16 + "True": 84 test-flag5285: - percentage: 85 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 15 + "True": 85 test-flag5286: - percentage: 86 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 14 + "True": 86 test-flag5287: - percentage: 87 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 13 + "True": 87 test-flag5288: - percentage: 88 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 12 + "True": 88 test-flag5289: - percentage: 89 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 11 + "True": 89 test-flag5290: - percentage: 90 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 10 + "True": 90 test-flag5291: - percentage: 91 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 9 + "True": 91 test-flag5292: - percentage: 92 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 8 + "True": 92 test-flag5293: - percentage: 93 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 7 + "True": 93 test-flag5294: - percentage: 94 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 6 + "True": 94 test-flag5295: - percentage: 95 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 5 + "True": 95 test-flag5296: - percentage: 96 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 4 + "True": 96 test-flag5297: - percentage: 97 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 3 + "True": 97 test-flag5298: - percentage: 98 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 2 + "True": 98 test-flag5299: - percentage: 99 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 1 + "True": 99 test-flag5300: - percentage: 0 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 100 + "True": 0 test-flag5301: - percentage: 1 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 99 + "True": 1 test-flag5302: - percentage: 2 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 98 + "True": 2 test-flag5303: - percentage: 3 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 97 + "True": 3 test-flag5304: - percentage: 4 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 96 + "True": 4 test-flag5305: - percentage: 5 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 95 + "True": 5 test-flag5306: - percentage: 6 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 94 + "True": 6 test-flag5307: - percentage: 7 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 93 + "True": 7 test-flag5308: - percentage: 8 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 92 + "True": 8 test-flag5309: - percentage: 9 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 91 + "True": 9 test-flag5310: - percentage: 10 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 90 + "True": 10 test-flag5311: - percentage: 11 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 89 + "True": 11 test-flag5312: - percentage: 12 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 88 + "True": 12 test-flag5313: - percentage: 13 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 87 + "True": 13 test-flag5314: - percentage: 14 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 86 + "True": 14 test-flag5315: - percentage: 15 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 85 + "True": 15 test-flag5316: - percentage: 16 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 84 + "True": 16 test-flag5317: - percentage: 17 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 83 + "True": 17 test-flag5318: - percentage: 18 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 82 + "True": 18 test-flag5319: - percentage: 19 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 81 + "True": 19 test-flag5320: - percentage: 20 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 80 + "True": 20 test-flag5321: - percentage: 21 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 79 + "True": 21 test-flag5322: - percentage: 22 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 78 + "True": 22 test-flag5323: - percentage: 23 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 77 + "True": 23 test-flag5324: - percentage: 24 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 76 + "True": 24 test-flag5325: - percentage: 25 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 75 + "True": 25 test-flag5326: - percentage: 26 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 74 + "True": 26 test-flag5327: - percentage: 27 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 73 + "True": 27 test-flag5328: - percentage: 28 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 72 + "True": 28 test-flag5329: - percentage: 29 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 71 + "True": 29 test-flag5330: - percentage: 30 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 70 + "True": 30 test-flag5331: - percentage: 31 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 69 + "True": 31 test-flag5332: - percentage: 32 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 68 + "True": 32 test-flag5333: - percentage: 33 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 67 + "True": 33 test-flag5334: - percentage: 34 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 66 + "True": 34 test-flag5335: - percentage: 35 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 65 + "True": 35 test-flag5336: - percentage: 36 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 64 + "True": 36 test-flag5337: - percentage: 37 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 63 + "True": 37 test-flag5338: - percentage: 38 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 62 + "True": 38 test-flag5339: - percentage: 39 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 61 + "True": 39 test-flag5340: - percentage: 40 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 60 + "True": 40 test-flag5341: - percentage: 41 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 59 + "True": 41 test-flag5342: - percentage: 42 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 58 + "True": 42 test-flag5343: - percentage: 43 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 57 + "True": 43 test-flag5344: - percentage: 44 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 56 + "True": 44 test-flag5345: - percentage: 45 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 55 + "True": 45 test-flag5346: - percentage: 46 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 54 + "True": 46 test-flag5347: - percentage: 47 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 53 + "True": 47 test-flag5348: - percentage: 48 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 52 + "True": 48 test-flag5349: - percentage: 49 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 51 + "True": 49 test-flag5350: - percentage: 50 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 50 + "True": 50 test-flag5351: - percentage: 51 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 49 + "True": 51 test-flag5352: - percentage: 52 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 48 + "True": 52 test-flag5353: - percentage: 53 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 47 + "True": 53 test-flag5354: - percentage: 54 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 46 + "True": 54 test-flag5355: - percentage: 55 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 45 + "True": 55 test-flag5356: - percentage: 56 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 44 + "True": 56 test-flag5357: - percentage: 57 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 43 + "True": 57 test-flag5358: - percentage: 58 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 42 + "True": 58 test-flag5359: - percentage: 59 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 41 + "True": 59 test-flag5360: - percentage: 60 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 40 + "True": 60 test-flag5361: - percentage: 61 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 39 + "True": 61 test-flag5362: - percentage: 62 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 38 + "True": 62 test-flag5363: - percentage: 63 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 37 + "True": 63 test-flag5364: - percentage: 64 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 36 + "True": 64 test-flag5365: - percentage: 65 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 35 + "True": 65 test-flag5366: - percentage: 66 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 34 + "True": 66 test-flag5367: - percentage: 67 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 33 + "True": 67 test-flag5368: - percentage: 68 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 32 + "True": 68 test-flag5369: - percentage: 69 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 31 + "True": 69 test-flag5370: - percentage: 70 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 30 + "True": 70 test-flag5371: - percentage: 71 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 29 + "True": 71 test-flag5372: - percentage: 72 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 28 + "True": 72 test-flag5373: - percentage: 73 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 27 + "True": 73 test-flag5374: - percentage: 74 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 26 + "True": 74 test-flag5375: - percentage: 75 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 25 + "True": 75 test-flag5376: - percentage: 76 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 24 + "True": 76 test-flag5377: - percentage: 77 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 23 + "True": 77 test-flag5378: - percentage: 78 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 22 + "True": 78 test-flag5379: - percentage: 79 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 21 + "True": 79 test-flag5380: - percentage: 80 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 20 + "True": 80 test-flag5381: - percentage: 81 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 19 + "True": 81 test-flag5382: - percentage: 82 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 18 + "True": 82 test-flag5383: - percentage: 83 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 17 + "True": 83 test-flag5384: - percentage: 84 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 16 + "True": 84 test-flag5385: - percentage: 85 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 15 + "True": 85 test-flag5386: - percentage: 86 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 14 + "True": 86 test-flag5387: - percentage: 87 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 13 + "True": 87 test-flag5388: - percentage: 88 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 12 + "True": 88 test-flag5389: - percentage: 89 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 11 + "True": 89 test-flag5390: - percentage: 90 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 10 + "True": 90 test-flag5391: - percentage: 91 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 9 + "True": 91 test-flag5392: - percentage: 92 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 8 + "True": 92 test-flag5393: - percentage: 93 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 7 + "True": 93 test-flag5394: - percentage: 94 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 6 + "True": 94 test-flag5395: - percentage: 95 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 5 + "True": 95 test-flag5396: - percentage: 96 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 4 + "True": 96 test-flag5397: - percentage: 97 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 3 + "True": 97 test-flag5398: - percentage: 98 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 2 + "True": 98 test-flag5399: - percentage: 99 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 1 + "True": 99 test-flag5400: - percentage: 0 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 100 + "True": 0 test-flag5401: - percentage: 1 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 99 + "True": 1 test-flag5402: - percentage: 2 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 98 + "True": 2 test-flag5403: - percentage: 3 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 97 + "True": 3 test-flag5404: - percentage: 4 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 96 + "True": 4 test-flag5405: - percentage: 5 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 95 + "True": 5 test-flag5406: - percentage: 6 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 94 + "True": 6 test-flag5407: - percentage: 7 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 93 + "True": 7 test-flag5408: - percentage: 8 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 92 + "True": 8 test-flag5409: - percentage: 9 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 91 + "True": 9 test-flag5410: - percentage: 10 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 90 + "True": 10 test-flag5411: - percentage: 11 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 89 + "True": 11 test-flag5412: - percentage: 12 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 88 + "True": 12 test-flag5413: - percentage: 13 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 87 + "True": 13 test-flag5414: - percentage: 14 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 86 + "True": 14 test-flag5415: - percentage: 15 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 85 + "True": 15 test-flag5416: - percentage: 16 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 84 + "True": 16 test-flag5417: - percentage: 17 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 83 + "True": 17 test-flag5418: - percentage: 18 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 82 + "True": 18 test-flag5419: - percentage: 19 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 81 + "True": 19 test-flag5420: - percentage: 20 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 80 + "True": 20 test-flag5421: - percentage: 21 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 79 + "True": 21 test-flag5422: - percentage: 22 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 78 + "True": 22 test-flag5423: - percentage: 23 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 77 + "True": 23 test-flag5424: - percentage: 24 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 76 + "True": 24 test-flag5425: - percentage: 25 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 75 + "True": 25 test-flag5426: - percentage: 26 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 74 + "True": 26 test-flag5427: - percentage: 27 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 73 + "True": 27 test-flag5428: - percentage: 28 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 72 + "True": 28 test-flag5429: - percentage: 29 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 71 + "True": 29 test-flag5430: - percentage: 30 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 70 + "True": 30 test-flag5431: - percentage: 31 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 69 + "True": 31 test-flag5432: - percentage: 32 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 68 + "True": 32 test-flag5433: - percentage: 33 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 67 + "True": 33 test-flag5434: - percentage: 34 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 66 + "True": 34 test-flag5435: - percentage: 35 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 65 + "True": 35 test-flag5436: - percentage: 36 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 64 + "True": 36 test-flag5437: - percentage: 37 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 63 + "True": 37 test-flag5438: - percentage: 38 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 62 + "True": 38 test-flag5439: - percentage: 39 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 61 + "True": 39 test-flag5440: - percentage: 40 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 60 + "True": 40 test-flag5441: - percentage: 41 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 59 + "True": 41 test-flag5442: - percentage: 42 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 58 + "True": 42 test-flag5443: - percentage: 43 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 57 + "True": 43 test-flag5444: - percentage: 44 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 56 + "True": 44 test-flag5445: - percentage: 45 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 55 + "True": 45 test-flag5446: - percentage: 46 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 54 + "True": 46 test-flag5447: - percentage: 47 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 53 + "True": 47 test-flag5448: - percentage: 48 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 52 + "True": 48 test-flag5449: - percentage: 49 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 51 + "True": 49 test-flag5450: - percentage: 50 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 50 + "True": 50 test-flag5451: - percentage: 51 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 49 + "True": 51 test-flag5452: - percentage: 52 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 48 + "True": 52 test-flag5453: - percentage: 53 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 47 + "True": 53 test-flag5454: - percentage: 54 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 46 + "True": 54 test-flag5455: - percentage: 55 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 45 + "True": 55 test-flag5456: - percentage: 56 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 44 + "True": 56 test-flag5457: - percentage: 57 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 43 + "True": 57 test-flag5458: - percentage: 58 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 42 + "True": 58 test-flag5459: - percentage: 59 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 41 + "True": 59 test-flag5460: - percentage: 60 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 40 + "True": 60 test-flag5461: - percentage: 61 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 39 + "True": 61 test-flag5462: - percentage: 62 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 38 + "True": 62 test-flag5463: - percentage: 63 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 37 + "True": 63 test-flag5464: - percentage: 64 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 36 + "True": 64 test-flag5465: - percentage: 65 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 35 + "True": 65 test-flag5466: - percentage: 66 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 34 + "True": 66 test-flag5467: - percentage: 67 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 33 + "True": 67 test-flag5468: - percentage: 68 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 32 + "True": 68 test-flag5469: - percentage: 69 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 31 + "True": 69 test-flag5470: - percentage: 70 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 30 + "True": 70 test-flag5471: - percentage: 71 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 29 + "True": 71 test-flag5472: - percentage: 72 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 28 + "True": 72 test-flag5473: - percentage: 73 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 27 + "True": 73 test-flag5474: - percentage: 74 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 26 + "True": 74 test-flag5475: - percentage: 75 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 25 + "True": 75 test-flag5476: - percentage: 76 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 24 + "True": 76 test-flag5477: - percentage: 77 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 23 + "True": 77 test-flag5478: - percentage: 78 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 22 + "True": 78 test-flag5479: - percentage: 79 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 21 + "True": 79 test-flag5480: - percentage: 80 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 20 + "True": 80 test-flag5481: - percentage: 81 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 19 + "True": 81 test-flag5482: - percentage: 82 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 18 + "True": 82 test-flag5483: - percentage: 83 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 17 + "True": 83 test-flag5484: - percentage: 84 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 16 + "True": 84 test-flag5485: - percentage: 85 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 15 + "True": 85 test-flag5486: - percentage: 86 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 14 + "True": 86 test-flag5487: - percentage: 87 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 13 + "True": 87 test-flag5488: - percentage: 88 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 12 + "True": 88 test-flag5489: - percentage: 89 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 11 + "True": 89 test-flag5490: - percentage: 90 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 10 + "True": 90 test-flag5491: - percentage: 91 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 9 + "True": 91 test-flag5492: - percentage: 92 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 8 + "True": 92 test-flag5493: - percentage: 93 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 7 + "True": 93 test-flag5494: - percentage: 94 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 6 + "True": 94 test-flag5495: - percentage: 95 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 5 + "True": 95 test-flag5496: - percentage: 96 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 4 + "True": 96 test-flag5497: - percentage: 97 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 3 + "True": 97 test-flag5498: - percentage: 98 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 2 + "True": 98 test-flag5499: - percentage: 99 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 1 + "True": 99 test-flag5500: - percentage: 0 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 100 + "True": 0 test-flag5501: - percentage: 1 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 99 + "True": 1 test-flag5502: - percentage: 2 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 98 + "True": 2 test-flag5503: - percentage: 3 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 97 + "True": 3 test-flag5504: - percentage: 4 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 96 + "True": 4 test-flag5505: - percentage: 5 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 95 + "True": 5 test-flag5506: - percentage: 6 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 94 + "True": 6 test-flag5507: - percentage: 7 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 93 + "True": 7 test-flag5508: - percentage: 8 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 92 + "True": 8 test-flag5509: - percentage: 9 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 91 + "True": 9 test-flag5510: - percentage: 10 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 90 + "True": 10 test-flag5511: - percentage: 11 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 89 + "True": 11 test-flag5512: - percentage: 12 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 88 + "True": 12 test-flag5513: - percentage: 13 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 87 + "True": 13 test-flag5514: - percentage: 14 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 86 + "True": 14 test-flag5515: - percentage: 15 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 85 + "True": 15 test-flag5516: - percentage: 16 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 84 + "True": 16 test-flag5517: - percentage: 17 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 83 + "True": 17 test-flag5518: - percentage: 18 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 82 + "True": 18 test-flag5519: - percentage: 19 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 81 + "True": 19 test-flag5520: - percentage: 20 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 80 + "True": 20 test-flag5521: - percentage: 21 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 79 + "True": 21 test-flag5522: - percentage: 22 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 78 + "True": 22 test-flag5523: - percentage: 23 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 77 + "True": 23 test-flag5524: - percentage: 24 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 76 + "True": 24 test-flag5525: - percentage: 25 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 75 + "True": 25 test-flag5526: - percentage: 26 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 74 + "True": 26 test-flag5527: - percentage: 27 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 73 + "True": 27 test-flag5528: - percentage: 28 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 72 + "True": 28 test-flag5529: - percentage: 29 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 71 + "True": 29 test-flag5530: - percentage: 30 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 70 + "True": 30 test-flag5531: - percentage: 31 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 69 + "True": 31 test-flag5532: - percentage: 32 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 68 + "True": 32 test-flag5533: - percentage: 33 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 67 + "True": 33 test-flag5534: - percentage: 34 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 66 + "True": 34 test-flag5535: - percentage: 35 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 65 + "True": 35 test-flag5536: - percentage: 36 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 64 + "True": 36 test-flag5537: - percentage: 37 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 63 + "True": 37 test-flag5538: - percentage: 38 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 62 + "True": 38 test-flag5539: - percentage: 39 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 61 + "True": 39 test-flag5540: - percentage: 40 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 60 + "True": 40 test-flag5541: - percentage: 41 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 59 + "True": 41 test-flag5542: - percentage: 42 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 58 + "True": 42 test-flag5543: - percentage: 43 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 57 + "True": 43 test-flag5544: - percentage: 44 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 56 + "True": 44 test-flag5545: - percentage: 45 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 55 + "True": 45 test-flag5546: - percentage: 46 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 54 + "True": 46 test-flag5547: - percentage: 47 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 53 + "True": 47 test-flag5548: - percentage: 48 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 52 + "True": 48 test-flag5549: - percentage: 49 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 51 + "True": 49 test-flag5550: - percentage: 50 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 50 + "True": 50 test-flag5551: - percentage: 51 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 49 + "True": 51 test-flag5552: - percentage: 52 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 48 + "True": 52 test-flag5553: - percentage: 53 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 47 + "True": 53 test-flag5554: - percentage: 54 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 46 + "True": 54 test-flag5555: - percentage: 55 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 45 + "True": 55 test-flag5556: - percentage: 56 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 44 + "True": 56 test-flag5557: - percentage: 57 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 43 + "True": 57 test-flag5558: - percentage: 58 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 42 + "True": 58 test-flag5559: - percentage: 59 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 41 + "True": 59 test-flag5560: - percentage: 60 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 40 + "True": 60 test-flag5561: - percentage: 61 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 39 + "True": 61 test-flag5562: - percentage: 62 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 38 + "True": 62 test-flag5563: - percentage: 63 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 37 + "True": 63 test-flag5564: - percentage: 64 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 36 + "True": 64 test-flag5565: - percentage: 65 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 35 + "True": 65 test-flag5566: - percentage: 66 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 34 + "True": 66 test-flag5567: - percentage: 67 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 33 + "True": 67 test-flag5568: - percentage: 68 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 32 + "True": 68 test-flag5569: - percentage: 69 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 31 + "True": 69 test-flag5570: - percentage: 70 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 30 + "True": 70 test-flag5571: - percentage: 71 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 29 + "True": 71 test-flag5572: - percentage: 72 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 28 + "True": 72 test-flag5573: - percentage: 73 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 27 + "True": 73 test-flag5574: - percentage: 74 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 26 + "True": 74 test-flag5575: - percentage: 75 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 25 + "True": 75 test-flag5576: - percentage: 76 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 24 + "True": 76 test-flag5577: - percentage: 77 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 23 + "True": 77 test-flag5578: - percentage: 78 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 22 + "True": 78 test-flag5579: - percentage: 79 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 21 + "True": 79 test-flag5580: - percentage: 80 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 20 + "True": 80 test-flag5581: - percentage: 81 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 19 + "True": 81 test-flag5582: - percentage: 82 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 18 + "True": 82 test-flag5583: - percentage: 83 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 17 + "True": 83 test-flag5584: - percentage: 84 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 16 + "True": 84 test-flag5585: - percentage: 85 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 15 + "True": 85 test-flag5586: - percentage: 86 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 14 + "True": 86 test-flag5587: - percentage: 87 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 13 + "True": 87 test-flag5588: - percentage: 88 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 12 + "True": 88 test-flag5589: - percentage: 89 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 11 + "True": 89 test-flag5590: - percentage: 90 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 10 + "True": 90 test-flag5591: - percentage: 91 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 9 + "True": 91 test-flag5592: - percentage: 92 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 8 + "True": 92 test-flag5593: - percentage: 93 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 7 + "True": 93 test-flag5594: - percentage: 94 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 6 + "True": 94 test-flag5595: - percentage: 95 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 5 + "True": 95 test-flag5596: - percentage: 96 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 4 + "True": 96 test-flag5597: - percentage: 97 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 3 + "True": 97 test-flag5598: - percentage: 98 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 2 + "True": 98 test-flag5599: - percentage: 99 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 1 + "True": 99 test-flag5600: - percentage: 0 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 100 + "True": 0 test-flag5601: - percentage: 1 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 99 + "True": 1 test-flag5602: - percentage: 2 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 98 + "True": 2 test-flag5603: - percentage: 3 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 97 + "True": 3 test-flag5604: - percentage: 4 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 96 + "True": 4 test-flag5605: - percentage: 5 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 95 + "True": 5 test-flag5606: - percentage: 6 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 94 + "True": 6 test-flag5607: - percentage: 7 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 93 + "True": 7 test-flag5608: - percentage: 8 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 92 + "True": 8 test-flag5609: - percentage: 9 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 91 + "True": 9 test-flag5610: - percentage: 10 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 90 + "True": 10 test-flag5611: - percentage: 11 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 89 + "True": 11 test-flag5612: - percentage: 12 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 88 + "True": 12 test-flag5613: - percentage: 13 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 87 + "True": 13 test-flag5614: - percentage: 14 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 86 + "True": 14 test-flag5615: - percentage: 15 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 85 + "True": 15 test-flag5616: - percentage: 16 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 84 + "True": 16 test-flag5617: - percentage: 17 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 83 + "True": 17 test-flag5618: - percentage: 18 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 82 + "True": 18 test-flag5619: - percentage: 19 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 81 + "True": 19 test-flag5620: - percentage: 20 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 80 + "True": 20 test-flag5621: - percentage: 21 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 79 + "True": 21 test-flag5622: - percentage: 22 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 78 + "True": 22 test-flag5623: - percentage: 23 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 77 + "True": 23 test-flag5624: - percentage: 24 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 76 + "True": 24 test-flag5625: - percentage: 25 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 75 + "True": 25 test-flag5626: - percentage: 26 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 74 + "True": 26 test-flag5627: - percentage: 27 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 73 + "True": 27 test-flag5628: - percentage: 28 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 72 + "True": 28 test-flag5629: - percentage: 29 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 71 + "True": 29 test-flag5630: - percentage: 30 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 70 + "True": 30 test-flag5631: - percentage: 31 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 69 + "True": 31 test-flag5632: - percentage: 32 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 68 + "True": 32 test-flag5633: - percentage: 33 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 67 + "True": 33 test-flag5634: - percentage: 34 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 66 + "True": 34 test-flag5635: - percentage: 35 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 65 + "True": 35 test-flag5636: - percentage: 36 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 64 + "True": 36 test-flag5637: - percentage: 37 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 63 + "True": 37 test-flag5638: - percentage: 38 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 62 + "True": 38 test-flag5639: - percentage: 39 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 61 + "True": 39 test-flag5640: - percentage: 40 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 60 + "True": 40 test-flag5641: - percentage: 41 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 59 + "True": 41 test-flag5642: - percentage: 42 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 58 + "True": 42 test-flag5643: - percentage: 43 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 57 + "True": 43 test-flag5644: - percentage: 44 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 56 + "True": 44 test-flag5645: - percentage: 45 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 55 + "True": 45 test-flag5646: - percentage: 46 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 54 + "True": 46 test-flag5647: - percentage: 47 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 53 + "True": 47 test-flag5648: - percentage: 48 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 52 + "True": 48 test-flag5649: - percentage: 49 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 51 + "True": 49 test-flag5650: - percentage: 50 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 50 + "True": 50 test-flag5651: - percentage: 51 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 49 + "True": 51 test-flag5652: - percentage: 52 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 48 + "True": 52 test-flag5653: - percentage: 53 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 47 + "True": 53 test-flag5654: - percentage: 54 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 46 + "True": 54 test-flag5655: - percentage: 55 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 45 + "True": 55 test-flag5656: - percentage: 56 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 44 + "True": 56 test-flag5657: - percentage: 57 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 43 + "True": 57 test-flag5658: - percentage: 58 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 42 + "True": 58 test-flag5659: - percentage: 59 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 41 + "True": 59 test-flag5660: - percentage: 60 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 40 + "True": 60 test-flag5661: - percentage: 61 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 39 + "True": 61 test-flag5662: - percentage: 62 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 38 + "True": 62 test-flag5663: - percentage: 63 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 37 + "True": 63 test-flag5664: - percentage: 64 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 36 + "True": 64 test-flag5665: - percentage: 65 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 35 + "True": 65 test-flag5666: - percentage: 66 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 34 + "True": 66 test-flag5667: - percentage: 67 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 33 + "True": 67 test-flag5668: - percentage: 68 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 32 + "True": 68 test-flag5669: - percentage: 69 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 31 + "True": 69 test-flag5670: - percentage: 70 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 30 + "True": 70 test-flag5671: - percentage: 71 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 29 + "True": 71 test-flag5672: - percentage: 72 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 28 + "True": 72 test-flag5673: - percentage: 73 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 27 + "True": 73 test-flag5674: - percentage: 74 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 26 + "True": 74 test-flag5675: - percentage: 75 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 25 + "True": 75 test-flag5676: - percentage: 76 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 24 + "True": 76 test-flag5677: - percentage: 77 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 23 + "True": 77 test-flag5678: - percentage: 78 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 22 + "True": 78 test-flag5679: - percentage: 79 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 21 + "True": 79 test-flag5680: - percentage: 80 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 20 + "True": 80 test-flag5681: - percentage: 81 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 19 + "True": 81 test-flag5682: - percentage: 82 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 18 + "True": 82 test-flag5683: - percentage: 83 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 17 + "True": 83 test-flag5684: - percentage: 84 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 16 + "True": 84 test-flag5685: - percentage: 85 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 15 + "True": 85 test-flag5686: - percentage: 86 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 14 + "True": 86 test-flag5687: - percentage: 87 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 13 + "True": 87 test-flag5688: - percentage: 88 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 12 + "True": 88 test-flag5689: - percentage: 89 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 11 + "True": 89 test-flag5690: - percentage: 90 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 10 + "True": 90 test-flag5691: - percentage: 91 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 9 + "True": 91 test-flag5692: - percentage: 92 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 8 + "True": 92 test-flag5693: - percentage: 93 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 7 + "True": 93 test-flag5694: - percentage: 94 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 6 + "True": 94 test-flag5695: - percentage: 95 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 5 + "True": 95 test-flag5696: - percentage: 96 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 4 + "True": 96 test-flag5697: - percentage: 97 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 3 + "True": 97 test-flag5698: - percentage: 98 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 2 + "True": 98 test-flag5699: - percentage: 99 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 1 + "True": 99 test-flag5700: - percentage: 0 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 100 + "True": 0 test-flag5701: - percentage: 1 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 99 + "True": 1 test-flag5702: - percentage: 2 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 98 + "True": 2 test-flag5703: - percentage: 3 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 97 + "True": 3 test-flag5704: - percentage: 4 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 96 + "True": 4 test-flag5705: - percentage: 5 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 95 + "True": 5 test-flag5706: - percentage: 6 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 94 + "True": 6 test-flag5707: - percentage: 7 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 93 + "True": 7 test-flag5708: - percentage: 8 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 92 + "True": 8 test-flag5709: - percentage: 9 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 91 + "True": 9 test-flag5710: - percentage: 10 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 90 + "True": 10 test-flag5711: - percentage: 11 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 89 + "True": 11 test-flag5712: - percentage: 12 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 88 + "True": 12 test-flag5713: - percentage: 13 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 87 + "True": 13 test-flag5714: - percentage: 14 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 86 + "True": 14 test-flag5715: - percentage: 15 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 85 + "True": 15 test-flag5716: - percentage: 16 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 84 + "True": 16 test-flag5717: - percentage: 17 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 83 + "True": 17 test-flag5718: - percentage: 18 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 82 + "True": 18 test-flag5719: - percentage: 19 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 81 + "True": 19 test-flag5720: - percentage: 20 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 80 + "True": 20 test-flag5721: - percentage: 21 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 79 + "True": 21 test-flag5722: - percentage: 22 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 78 + "True": 22 test-flag5723: - percentage: 23 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 77 + "True": 23 test-flag5724: - percentage: 24 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 76 + "True": 24 test-flag5725: - percentage: 25 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 75 + "True": 25 test-flag5726: - percentage: 26 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 74 + "True": 26 test-flag5727: - percentage: 27 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 73 + "True": 27 test-flag5728: - percentage: 28 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 72 + "True": 28 test-flag5729: - percentage: 29 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 71 + "True": 29 test-flag5730: - percentage: 30 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 70 + "True": 30 test-flag5731: - percentage: 31 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 69 + "True": 31 test-flag5732: - percentage: 32 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 68 + "True": 32 test-flag5733: - percentage: 33 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 67 + "True": 33 test-flag5734: - percentage: 34 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 66 + "True": 34 test-flag5735: - percentage: 35 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 65 + "True": 35 test-flag5736: - percentage: 36 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 64 + "True": 36 test-flag5737: - percentage: 37 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 63 + "True": 37 test-flag5738: - percentage: 38 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 62 + "True": 38 test-flag5739: - percentage: 39 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 61 + "True": 39 test-flag5740: - percentage: 40 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 60 + "True": 40 test-flag5741: - percentage: 41 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 59 + "True": 41 test-flag5742: - percentage: 42 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 58 + "True": 42 test-flag5743: - percentage: 43 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 57 + "True": 43 test-flag5744: - percentage: 44 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 56 + "True": 44 test-flag5745: - percentage: 45 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 55 + "True": 45 test-flag5746: - percentage: 46 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 54 + "True": 46 test-flag5747: - percentage: 47 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 53 + "True": 47 test-flag5748: - percentage: 48 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 52 + "True": 48 test-flag5749: - percentage: 49 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 51 + "True": 49 test-flag5750: - percentage: 50 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 50 + "True": 50 test-flag5751: - percentage: 51 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 49 + "True": 51 test-flag5752: - percentage: 52 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 48 + "True": 52 test-flag5753: - percentage: 53 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 47 + "True": 53 test-flag5754: - percentage: 54 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 46 + "True": 54 test-flag5755: - percentage: 55 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 45 + "True": 55 test-flag5756: - percentage: 56 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 44 + "True": 56 test-flag5757: - percentage: 57 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 43 + "True": 57 test-flag5758: - percentage: 58 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 42 + "True": 58 test-flag5759: - percentage: 59 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 41 + "True": 59 test-flag5760: - percentage: 60 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 40 + "True": 60 test-flag5761: - percentage: 61 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 39 + "True": 61 test-flag5762: - percentage: 62 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 38 + "True": 62 test-flag5763: - percentage: 63 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 37 + "True": 63 test-flag5764: - percentage: 64 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 36 + "True": 64 test-flag5765: - percentage: 65 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 35 + "True": 65 test-flag5766: - percentage: 66 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 34 + "True": 66 test-flag5767: - percentage: 67 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 33 + "True": 67 test-flag5768: - percentage: 68 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 32 + "True": 68 test-flag5769: - percentage: 69 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 31 + "True": 69 test-flag5770: - percentage: 70 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 30 + "True": 70 test-flag5771: - percentage: 71 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 29 + "True": 71 test-flag5772: - percentage: 72 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 28 + "True": 72 test-flag5773: - percentage: 73 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 27 + "True": 73 test-flag5774: - percentage: 74 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 26 + "True": 74 test-flag5775: - percentage: 75 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 25 + "True": 75 test-flag5776: - percentage: 76 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 24 + "True": 76 test-flag5777: - percentage: 77 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 23 + "True": 77 test-flag5778: - percentage: 78 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 22 + "True": 78 test-flag5779: - percentage: 79 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 21 + "True": 79 test-flag5780: - percentage: 80 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 20 + "True": 80 test-flag5781: - percentage: 81 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 19 + "True": 81 test-flag5782: - percentage: 82 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 18 + "True": 82 test-flag5783: - percentage: 83 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 17 + "True": 83 test-flag5784: - percentage: 84 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 16 + "True": 84 test-flag5785: - percentage: 85 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 15 + "True": 85 test-flag5786: - percentage: 86 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 14 + "True": 86 test-flag5787: - percentage: 87 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 13 + "True": 87 test-flag5788: - percentage: 88 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 12 + "True": 88 test-flag5789: - percentage: 89 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 11 + "True": 89 test-flag5790: - percentage: 90 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 10 + "True": 90 test-flag5791: - percentage: 91 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 9 + "True": 91 test-flag5792: - percentage: 92 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 8 + "True": 92 test-flag5793: - percentage: 93 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 7 + "True": 93 test-flag5794: - percentage: 94 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 6 + "True": 94 test-flag5795: - percentage: 95 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 5 + "True": 95 test-flag5796: - percentage: 96 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 4 + "True": 96 test-flag5797: - percentage: 97 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 3 + "True": 97 test-flag5798: - percentage: 98 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 2 + "True": 98 test-flag5799: - percentage: 99 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 1 + "True": 99 test-flag5800: - percentage: 0 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 100 + "True": 0 test-flag5801: - percentage: 1 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 99 + "True": 1 test-flag5802: - percentage: 2 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 98 + "True": 2 test-flag5803: - percentage: 3 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 97 + "True": 3 test-flag5804: - percentage: 4 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 96 + "True": 4 test-flag5805: - percentage: 5 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 95 + "True": 5 test-flag5806: - percentage: 6 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 94 + "True": 6 test-flag5807: - percentage: 7 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 93 + "True": 7 test-flag5808: - percentage: 8 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 92 + "True": 8 test-flag5809: - percentage: 9 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 91 + "True": 9 test-flag5810: - percentage: 10 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 90 + "True": 10 test-flag5811: - percentage: 11 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 89 + "True": 11 test-flag5812: - percentage: 12 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 88 + "True": 12 test-flag5813: - percentage: 13 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 87 + "True": 13 test-flag5814: - percentage: 14 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 86 + "True": 14 test-flag5815: - percentage: 15 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 85 + "True": 15 test-flag5816: - percentage: 16 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 84 + "True": 16 test-flag5817: - percentage: 17 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 83 + "True": 17 test-flag5818: - percentage: 18 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 82 + "True": 18 test-flag5819: - percentage: 19 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 81 + "True": 19 test-flag5820: - percentage: 20 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 80 + "True": 20 test-flag5821: - percentage: 21 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 79 + "True": 21 test-flag5822: - percentage: 22 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 78 + "True": 22 test-flag5823: - percentage: 23 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 77 + "True": 23 test-flag5824: - percentage: 24 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 76 + "True": 24 test-flag5825: - percentage: 25 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 75 + "True": 25 test-flag5826: - percentage: 26 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 74 + "True": 26 test-flag5827: - percentage: 27 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 73 + "True": 27 test-flag5828: - percentage: 28 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 72 + "True": 28 test-flag5829: - percentage: 29 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 71 + "True": 29 test-flag5830: - percentage: 30 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 70 + "True": 30 test-flag5831: - percentage: 31 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 69 + "True": 31 test-flag5832: - percentage: 32 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 68 + "True": 32 test-flag5833: - percentage: 33 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 67 + "True": 33 test-flag5834: - percentage: 34 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 66 + "True": 34 test-flag5835: - percentage: 35 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 65 + "True": 35 test-flag5836: - percentage: 36 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 64 + "True": 36 test-flag5837: - percentage: 37 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 63 + "True": 37 test-flag5838: - percentage: 38 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 62 + "True": 38 test-flag5839: - percentage: 39 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 61 + "True": 39 test-flag5840: - percentage: 40 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 60 + "True": 40 test-flag5841: - percentage: 41 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 59 + "True": 41 test-flag5842: - percentage: 42 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 58 + "True": 42 test-flag5843: - percentage: 43 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 57 + "True": 43 test-flag5844: - percentage: 44 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 56 + "True": 44 test-flag5845: - percentage: 45 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 55 + "True": 45 test-flag5846: - percentage: 46 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 54 + "True": 46 test-flag5847: - percentage: 47 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 53 + "True": 47 test-flag5848: - percentage: 48 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 52 + "True": 48 test-flag5849: - percentage: 49 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 51 + "True": 49 test-flag5850: - percentage: 50 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 50 + "True": 50 test-flag5851: - percentage: 51 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 49 + "True": 51 test-flag5852: - percentage: 52 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 48 + "True": 52 test-flag5853: - percentage: 53 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 47 + "True": 53 test-flag5854: - percentage: 54 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 46 + "True": 54 test-flag5855: - percentage: 55 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 45 + "True": 55 test-flag5856: - percentage: 56 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 44 + "True": 56 test-flag5857: - percentage: 57 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 43 + "True": 57 test-flag5858: - percentage: 58 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 42 + "True": 58 test-flag5859: - percentage: 59 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 41 + "True": 59 test-flag5860: - percentage: 60 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 40 + "True": 60 test-flag5861: - percentage: 61 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 39 + "True": 61 test-flag5862: - percentage: 62 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 38 + "True": 62 test-flag5863: - percentage: 63 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 37 + "True": 63 test-flag5864: - percentage: 64 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 36 + "True": 64 test-flag5865: - percentage: 65 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 35 + "True": 65 test-flag5866: - percentage: 66 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 34 + "True": 66 test-flag5867: - percentage: 67 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 33 + "True": 67 test-flag5868: - percentage: 68 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 32 + "True": 68 test-flag5869: - percentage: 69 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 31 + "True": 69 test-flag5870: - percentage: 70 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 30 + "True": 70 test-flag5871: - percentage: 71 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 29 + "True": 71 test-flag5872: - percentage: 72 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 28 + "True": 72 test-flag5873: - percentage: 73 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 27 + "True": 73 test-flag5874: - percentage: 74 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 26 + "True": 74 test-flag5875: - percentage: 75 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 25 + "True": 75 test-flag5876: - percentage: 76 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 24 + "True": 76 test-flag5877: - percentage: 77 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 23 + "True": 77 test-flag5878: - percentage: 78 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 22 + "True": 78 test-flag5879: - percentage: 79 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 21 + "True": 79 test-flag5880: - percentage: 80 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 20 + "True": 80 test-flag5881: - percentage: 81 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 19 + "True": 81 test-flag5882: - percentage: 82 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 18 + "True": 82 test-flag5883: - percentage: 83 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 17 + "True": 83 test-flag5884: - percentage: 84 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 16 + "True": 84 test-flag5885: - percentage: 85 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 15 + "True": 85 test-flag5886: - percentage: 86 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 14 + "True": 86 test-flag5887: - percentage: 87 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 13 + "True": 87 test-flag5888: - percentage: 88 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 12 + "True": 88 test-flag5889: - percentage: 89 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 11 + "True": 89 test-flag5890: - percentage: 90 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 10 + "True": 90 test-flag5891: - percentage: 91 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 9 + "True": 91 test-flag5892: - percentage: 92 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 8 + "True": 92 test-flag5893: - percentage: 93 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 7 + "True": 93 test-flag5894: - percentage: 94 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 6 + "True": 94 test-flag5895: - percentage: 95 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 5 + "True": 95 test-flag5896: - percentage: 96 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 4 + "True": 96 test-flag5897: - percentage: 97 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 3 + "True": 97 test-flag5898: - percentage: 98 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 2 + "True": 98 test-flag5899: - percentage: 99 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 1 + "True": 99 test-flag5900: - percentage: 0 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 100 + "True": 0 test-flag5901: - percentage: 1 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 99 + "True": 1 test-flag5902: - percentage: 2 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 98 + "True": 2 test-flag5903: - percentage: 3 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 97 + "True": 3 test-flag5904: - percentage: 4 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 96 + "True": 4 test-flag5905: - percentage: 5 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 95 + "True": 5 test-flag5906: - percentage: 6 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 94 + "True": 6 test-flag5907: - percentage: 7 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 93 + "True": 7 test-flag5908: - percentage: 8 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 92 + "True": 8 test-flag5909: - percentage: 9 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 91 + "True": 9 test-flag5910: - percentage: 10 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 90 + "True": 10 test-flag5911: - percentage: 11 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 89 + "True": 11 test-flag5912: - percentage: 12 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 88 + "True": 12 test-flag5913: - percentage: 13 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 87 + "True": 13 test-flag5914: - percentage: 14 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 86 + "True": 14 test-flag5915: - percentage: 15 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 85 + "True": 15 test-flag5916: - percentage: 16 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 84 + "True": 16 test-flag5917: - percentage: 17 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 83 + "True": 17 test-flag5918: - percentage: 18 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 82 + "True": 18 test-flag5919: - percentage: 19 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 81 + "True": 19 test-flag5920: - percentage: 20 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 80 + "True": 20 test-flag5921: - percentage: 21 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 79 + "True": 21 test-flag5922: - percentage: 22 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 78 + "True": 22 test-flag5923: - percentage: 23 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 77 + "True": 23 test-flag5924: - percentage: 24 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 76 + "True": 24 test-flag5925: - percentage: 25 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 75 + "True": 25 test-flag5926: - percentage: 26 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 74 + "True": 26 test-flag5927: - percentage: 27 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 73 + "True": 27 test-flag5928: - percentage: 28 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 72 + "True": 28 test-flag5929: - percentage: 29 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 71 + "True": 29 test-flag5930: - percentage: 30 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 70 + "True": 30 test-flag5931: - percentage: 31 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 69 + "True": 31 test-flag5932: - percentage: 32 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 68 + "True": 32 test-flag5933: - percentage: 33 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 67 + "True": 33 test-flag5934: - percentage: 34 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 66 + "True": 34 test-flag5935: - percentage: 35 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 65 + "True": 35 test-flag5936: - percentage: 36 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 64 + "True": 36 test-flag5937: - percentage: 37 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 63 + "True": 37 test-flag5938: - percentage: 38 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 62 + "True": 38 test-flag5939: - percentage: 39 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 61 + "True": 39 test-flag5940: - percentage: 40 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 60 + "True": 40 test-flag5941: - percentage: 41 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 59 + "True": 41 test-flag5942: - percentage: 42 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 58 + "True": 42 test-flag5943: - percentage: 43 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 57 + "True": 43 test-flag5944: - percentage: 44 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 56 + "True": 44 test-flag5945: - percentage: 45 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 55 + "True": 45 test-flag5946: - percentage: 46 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 54 + "True": 46 test-flag5947: - percentage: 47 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 53 + "True": 47 test-flag5948: - percentage: 48 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 52 + "True": 48 test-flag5949: - percentage: 49 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 51 + "True": 49 test-flag5950: - percentage: 50 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 50 + "True": 50 test-flag5951: - percentage: 51 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 49 + "True": 51 test-flag5952: - percentage: 52 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 48 + "True": 52 test-flag5953: - percentage: 53 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 47 + "True": 53 test-flag5954: - percentage: 54 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 46 + "True": 54 test-flag5955: - percentage: 55 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 45 + "True": 55 test-flag5956: - percentage: 56 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 44 + "True": 56 test-flag5957: - percentage: 57 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 43 + "True": 57 test-flag5958: - percentage: 58 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 42 + "True": 58 test-flag5959: - percentage: 59 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 41 + "True": 59 test-flag5960: - percentage: 60 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 40 + "True": 60 test-flag5961: - percentage: 61 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 39 + "True": 61 test-flag5962: - percentage: 62 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 38 + "True": 62 test-flag5963: - percentage: 63 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 37 + "True": 63 test-flag5964: - percentage: 64 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 36 + "True": 64 test-flag5965: - percentage: 65 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 35 + "True": 65 test-flag5966: - percentage: 66 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 34 + "True": 66 test-flag5967: - percentage: 67 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 33 + "True": 67 test-flag5968: - percentage: 68 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 32 + "True": 68 test-flag5969: - percentage: 69 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 31 + "True": 69 test-flag5970: - percentage: 70 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 30 + "True": 70 test-flag5971: - percentage: 71 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 29 + "True": 71 test-flag5972: - percentage: 72 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 28 + "True": 72 test-flag5973: - percentage: 73 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 27 + "True": 73 test-flag5974: - percentage: 74 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 26 + "True": 74 test-flag5975: - percentage: 75 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 25 + "True": 75 test-flag5976: - percentage: 76 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 24 + "True": 76 test-flag5977: - percentage: 77 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 23 + "True": 77 test-flag5978: - percentage: 78 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 22 + "True": 78 test-flag5979: - percentage: 79 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 21 + "True": 79 test-flag5980: - percentage: 80 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 20 + "True": 80 test-flag5981: - percentage: 81 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 19 + "True": 81 test-flag5982: - percentage: 82 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 18 + "True": 82 test-flag5983: - percentage: 83 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 17 + "True": 83 test-flag5984: - percentage: 84 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 16 + "True": 84 test-flag5985: - percentage: 85 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 15 + "True": 85 test-flag5986: - percentage: 86 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 14 + "True": 86 test-flag5987: - percentage: 87 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 13 + "True": 87 test-flag5988: - percentage: 88 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 12 + "True": 88 test-flag5989: - percentage: 89 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 11 + "True": 89 test-flag5990: - percentage: 90 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 10 + "True": 90 test-flag5991: - percentage: 91 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 9 + "True": 91 test-flag5992: - percentage: 92 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 8 + "True": 92 test-flag5993: - percentage: 93 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 7 + "True": 93 test-flag5994: - percentage: 94 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 6 + "True": 94 test-flag5995: - percentage: 95 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 5 + "True": 95 test-flag5996: - percentage: 96 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 4 + "True": 96 test-flag5997: - percentage: 97 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 3 + "True": 97 test-flag5998: - percentage: 98 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 2 + "True": 98 test-flag5999: - percentage: 99 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 1 + "True": 99 test-flag6000: - percentage: 0 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 100 + "True": 0 test-flag6001: - percentage: 1 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 99 + "True": 1 test-flag6002: - percentage: 2 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 98 + "True": 2 test-flag6003: - percentage: 3 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 97 + "True": 3 test-flag6004: - percentage: 4 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 96 + "True": 4 test-flag6005: - percentage: 5 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 95 + "True": 5 test-flag6006: - percentage: 6 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 94 + "True": 6 test-flag6007: - percentage: 7 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 93 + "True": 7 test-flag6008: - percentage: 8 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 92 + "True": 8 test-flag6009: - percentage: 9 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 91 + "True": 9 test-flag6010: - percentage: 10 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 90 + "True": 10 test-flag6011: - percentage: 11 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 89 + "True": 11 test-flag6012: - percentage: 12 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 88 + "True": 12 test-flag6013: - percentage: 13 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 87 + "True": 13 test-flag6014: - percentage: 14 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 86 + "True": 14 test-flag6015: - percentage: 15 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 85 + "True": 15 test-flag6016: - percentage: 16 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 84 + "True": 16 test-flag6017: - percentage: 17 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 83 + "True": 17 test-flag6018: - percentage: 18 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 82 + "True": 18 test-flag6019: - percentage: 19 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 81 + "True": 19 test-flag6020: - percentage: 20 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 80 + "True": 20 test-flag6021: - percentage: 21 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 79 + "True": 21 test-flag6022: - percentage: 22 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 78 + "True": 22 test-flag6023: - percentage: 23 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 77 + "True": 23 test-flag6024: - percentage: 24 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 76 + "True": 24 test-flag6025: - percentage: 25 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 75 + "True": 25 test-flag6026: - percentage: 26 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 74 + "True": 26 test-flag6027: - percentage: 27 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 73 + "True": 27 test-flag6028: - percentage: 28 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 72 + "True": 28 test-flag6029: - percentage: 29 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 71 + "True": 29 test-flag6030: - percentage: 30 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 70 + "True": 30 test-flag6031: - percentage: 31 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 69 + "True": 31 test-flag6032: - percentage: 32 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 68 + "True": 32 test-flag6033: - percentage: 33 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 67 + "True": 33 test-flag6034: - percentage: 34 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 66 + "True": 34 test-flag6035: - percentage: 35 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 65 + "True": 35 test-flag6036: - percentage: 36 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 64 + "True": 36 test-flag6037: - percentage: 37 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 63 + "True": 37 test-flag6038: - percentage: 38 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 62 + "True": 38 test-flag6039: - percentage: 39 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 61 + "True": 39 test-flag6040: - percentage: 40 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 60 + "True": 40 test-flag6041: - percentage: 41 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 59 + "True": 41 test-flag6042: - percentage: 42 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 58 + "True": 42 test-flag6043: - percentage: 43 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 57 + "True": 43 test-flag6044: - percentage: 44 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 56 + "True": 44 test-flag6045: - percentage: 45 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 55 + "True": 45 test-flag6046: - percentage: 46 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 54 + "True": 46 test-flag6047: - percentage: 47 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 53 + "True": 47 test-flag6048: - percentage: 48 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 52 + "True": 48 test-flag6049: - percentage: 49 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 51 + "True": 49 test-flag6050: - percentage: 50 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 50 + "True": 50 test-flag6051: - percentage: 51 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 49 + "True": 51 test-flag6052: - percentage: 52 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 48 + "True": 52 test-flag6053: - percentage: 53 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 47 + "True": 53 test-flag6054: - percentage: 54 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 46 + "True": 54 test-flag6055: - percentage: 55 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 45 + "True": 55 test-flag6056: - percentage: 56 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 44 + "True": 56 test-flag6057: - percentage: 57 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 43 + "True": 57 test-flag6058: - percentage: 58 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 42 + "True": 58 test-flag6059: - percentage: 59 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 41 + "True": 59 test-flag6060: - percentage: 60 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 40 + "True": 60 test-flag6061: - percentage: 61 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 39 + "True": 61 test-flag6062: - percentage: 62 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 38 + "True": 62 test-flag6063: - percentage: 63 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 37 + "True": 63 test-flag6064: - percentage: 64 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 36 + "True": 64 test-flag6065: - percentage: 65 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 35 + "True": 65 test-flag6066: - percentage: 66 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 34 + "True": 66 test-flag6067: - percentage: 67 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 33 + "True": 67 test-flag6068: - percentage: 68 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 32 + "True": 68 test-flag6069: - percentage: 69 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 31 + "True": 69 test-flag6070: - percentage: 70 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 30 + "True": 70 test-flag6071: - percentage: 71 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 29 + "True": 71 test-flag6072: - percentage: 72 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 28 + "True": 72 test-flag6073: - percentage: 73 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 27 + "True": 73 test-flag6074: - percentage: 74 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 26 + "True": 74 test-flag6075: - percentage: 75 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 25 + "True": 75 test-flag6076: - percentage: 76 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 24 + "True": 76 test-flag6077: - percentage: 77 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 23 + "True": 77 test-flag6078: - percentage: 78 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 22 + "True": 78 test-flag6079: - percentage: 79 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 21 + "True": 79 test-flag6080: - percentage: 80 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 20 + "True": 80 test-flag6081: - percentage: 81 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 19 + "True": 81 test-flag6082: - percentage: 82 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 18 + "True": 82 test-flag6083: - percentage: 83 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 17 + "True": 83 test-flag6084: - percentage: 84 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 16 + "True": 84 test-flag6085: - percentage: 85 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 15 + "True": 85 test-flag6086: - percentage: 86 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 14 + "True": 86 test-flag6087: - percentage: 87 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 13 + "True": 87 test-flag6088: - percentage: 88 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 12 + "True": 88 test-flag6089: - percentage: 89 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 11 + "True": 89 test-flag6090: - percentage: 90 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 10 + "True": 90 test-flag6091: - percentage: 91 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 9 + "True": 91 test-flag6092: - percentage: 92 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 8 + "True": 92 test-flag6093: - percentage: 93 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 7 + "True": 93 test-flag6094: - percentage: 94 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 6 + "True": 94 test-flag6095: - percentage: 95 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 5 + "True": 95 test-flag6096: - percentage: 96 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 4 + "True": 96 test-flag6097: - percentage: 97 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 3 + "True": 97 test-flag6098: - percentage: 98 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 2 + "True": 98 test-flag6099: - percentage: 99 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 1 + "True": 99 test-flag6100: - percentage: 0 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 100 + "True": 0 test-flag6101: - percentage: 1 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 99 + "True": 1 test-flag6102: - percentage: 2 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 98 + "True": 2 test-flag6103: - percentage: 3 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 97 + "True": 3 test-flag6104: - percentage: 4 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 96 + "True": 4 test-flag6105: - percentage: 5 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 95 + "True": 5 test-flag6106: - percentage: 6 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 94 + "True": 6 test-flag6107: - percentage: 7 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 93 + "True": 7 test-flag6108: - percentage: 8 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 92 + "True": 8 test-flag6109: - percentage: 9 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 91 + "True": 9 test-flag6110: - percentage: 10 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 90 + "True": 10 test-flag6111: - percentage: 11 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 89 + "True": 11 test-flag6112: - percentage: 12 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 88 + "True": 12 test-flag6113: - percentage: 13 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 87 + "True": 13 test-flag6114: - percentage: 14 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 86 + "True": 14 test-flag6115: - percentage: 15 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 85 + "True": 15 test-flag6116: - percentage: 16 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 84 + "True": 16 test-flag6117: - percentage: 17 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 83 + "True": 17 test-flag6118: - percentage: 18 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 82 + "True": 18 test-flag6119: - percentage: 19 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 81 + "True": 19 test-flag6120: - percentage: 20 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 80 + "True": 20 test-flag6121: - percentage: 21 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 79 + "True": 21 test-flag6122: - percentage: 22 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 78 + "True": 22 test-flag6123: - percentage: 23 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 77 + "True": 23 test-flag6124: - percentage: 24 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 76 + "True": 24 test-flag6125: - percentage: 25 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 75 + "True": 25 test-flag6126: - percentage: 26 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 74 + "True": 26 test-flag6127: - percentage: 27 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 73 + "True": 27 test-flag6128: - percentage: 28 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 72 + "True": 28 test-flag6129: - percentage: 29 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 71 + "True": 29 test-flag6130: - percentage: 30 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 70 + "True": 30 test-flag6131: - percentage: 31 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 69 + "True": 31 test-flag6132: - percentage: 32 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 68 + "True": 32 test-flag6133: - percentage: 33 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 67 + "True": 33 test-flag6134: - percentage: 34 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 66 + "True": 34 test-flag6135: - percentage: 35 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 65 + "True": 35 test-flag6136: - percentage: 36 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 64 + "True": 36 test-flag6137: - percentage: 37 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 63 + "True": 37 test-flag6138: - percentage: 38 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 62 + "True": 38 test-flag6139: - percentage: 39 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 61 + "True": 39 test-flag6140: - percentage: 40 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 60 + "True": 40 test-flag6141: - percentage: 41 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 59 + "True": 41 test-flag6142: - percentage: 42 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 58 + "True": 42 test-flag6143: - percentage: 43 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 57 + "True": 43 test-flag6144: - percentage: 44 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 56 + "True": 44 test-flag6145: - percentage: 45 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 55 + "True": 45 test-flag6146: - percentage: 46 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 54 + "True": 46 test-flag6147: - percentage: 47 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 53 + "True": 47 test-flag6148: - percentage: 48 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 52 + "True": 48 test-flag6149: - percentage: 49 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 51 + "True": 49 test-flag6150: - percentage: 50 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 50 + "True": 50 test-flag6151: - percentage: 51 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 49 + "True": 51 test-flag6152: - percentage: 52 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 48 + "True": 52 test-flag6153: - percentage: 53 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 47 + "True": 53 test-flag6154: - percentage: 54 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 46 + "True": 54 test-flag6155: - percentage: 55 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 45 + "True": 55 test-flag6156: - percentage: 56 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 44 + "True": 56 test-flag6157: - percentage: 57 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 43 + "True": 57 test-flag6158: - percentage: 58 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 42 + "True": 58 test-flag6159: - percentage: 59 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 41 + "True": 59 test-flag6160: - percentage: 60 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 40 + "True": 60 test-flag6161: - percentage: 61 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 39 + "True": 61 test-flag6162: - percentage: 62 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 38 + "True": 62 test-flag6163: - percentage: 63 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 37 + "True": 63 test-flag6164: - percentage: 64 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 36 + "True": 64 test-flag6165: - percentage: 65 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 35 + "True": 65 test-flag6166: - percentage: 66 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 34 + "True": 66 test-flag6167: - percentage: 67 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 33 + "True": 67 test-flag6168: - percentage: 68 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 32 + "True": 68 test-flag6169: - percentage: 69 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 31 + "True": 69 test-flag6170: - percentage: 70 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 30 + "True": 70 test-flag6171: - percentage: 71 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 29 + "True": 71 test-flag6172: - percentage: 72 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 28 + "True": 72 test-flag6173: - percentage: 73 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 27 + "True": 73 test-flag6174: - percentage: 74 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 26 + "True": 74 test-flag6175: - percentage: 75 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 25 + "True": 75 test-flag6176: - percentage: 76 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 24 + "True": 76 test-flag6177: - percentage: 77 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 23 + "True": 77 test-flag6178: - percentage: 78 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 22 + "True": 78 test-flag6179: - percentage: 79 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 21 + "True": 79 test-flag6180: - percentage: 80 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 20 + "True": 80 test-flag6181: - percentage: 81 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 19 + "True": 81 test-flag6182: - percentage: 82 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 18 + "True": 82 test-flag6183: - percentage: 83 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 17 + "True": 83 test-flag6184: - percentage: 84 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 16 + "True": 84 test-flag6185: - percentage: 85 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 15 + "True": 85 test-flag6186: - percentage: 86 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 14 + "True": 86 test-flag6187: - percentage: 87 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 13 + "True": 87 test-flag6188: - percentage: 88 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 12 + "True": 88 test-flag6189: - percentage: 89 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 11 + "True": 89 test-flag6190: - percentage: 90 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 10 + "True": 90 test-flag6191: - percentage: 91 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 9 + "True": 91 test-flag6192: - percentage: 92 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 8 + "True": 92 test-flag6193: - percentage: 93 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 7 + "True": 93 test-flag6194: - percentage: 94 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 6 + "True": 94 test-flag6195: - percentage: 95 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 5 + "True": 95 test-flag6196: - percentage: 96 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 4 + "True": 96 test-flag6197: - percentage: 97 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 3 + "True": 97 test-flag6198: - percentage: 98 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 2 + "True": 98 test-flag6199: - percentage: 99 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 1 + "True": 99 test-flag6200: - percentage: 0 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 100 + "True": 0 test-flag6201: - percentage: 1 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 99 + "True": 1 test-flag6202: - percentage: 2 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 98 + "True": 2 test-flag6203: - percentage: 3 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 97 + "True": 3 test-flag6204: - percentage: 4 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 96 + "True": 4 test-flag6205: - percentage: 5 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 95 + "True": 5 test-flag6206: - percentage: 6 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 94 + "True": 6 test-flag6207: - percentage: 7 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 93 + "True": 7 test-flag6208: - percentage: 8 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 92 + "True": 8 test-flag6209: - percentage: 9 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 91 + "True": 9 test-flag6210: - percentage: 10 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 90 + "True": 10 test-flag6211: - percentage: 11 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 89 + "True": 11 test-flag6212: - percentage: 12 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 88 + "True": 12 test-flag6213: - percentage: 13 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 87 + "True": 13 test-flag6214: - percentage: 14 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 86 + "True": 14 test-flag6215: - percentage: 15 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 85 + "True": 15 test-flag6216: - percentage: 16 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 84 + "True": 16 test-flag6217: - percentage: 17 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 83 + "True": 17 test-flag6218: - percentage: 18 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 82 + "True": 18 test-flag6219: - percentage: 19 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 81 + "True": 19 test-flag6220: - percentage: 20 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 80 + "True": 20 test-flag6221: - percentage: 21 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 79 + "True": 21 test-flag6222: - percentage: 22 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 78 + "True": 22 test-flag6223: - percentage: 23 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 77 + "True": 23 test-flag6224: - percentage: 24 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 76 + "True": 24 test-flag6225: - percentage: 25 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 75 + "True": 25 test-flag6226: - percentage: 26 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 74 + "True": 26 test-flag6227: - percentage: 27 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 73 + "True": 27 test-flag6228: - percentage: 28 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 72 + "True": 28 test-flag6229: - percentage: 29 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 71 + "True": 29 test-flag6230: - percentage: 30 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 70 + "True": 30 test-flag6231: - percentage: 31 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 69 + "True": 31 test-flag6232: - percentage: 32 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 68 + "True": 32 test-flag6233: - percentage: 33 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 67 + "True": 33 test-flag6234: - percentage: 34 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 66 + "True": 34 test-flag6235: - percentage: 35 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 65 + "True": 35 test-flag6236: - percentage: 36 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 64 + "True": 36 test-flag6237: - percentage: 37 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 63 + "True": 37 test-flag6238: - percentage: 38 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 62 + "True": 38 test-flag6239: - percentage: 39 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 61 + "True": 39 test-flag6240: - percentage: 40 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 60 + "True": 40 test-flag6241: - percentage: 41 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 59 + "True": 41 test-flag6242: - percentage: 42 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 58 + "True": 42 test-flag6243: - percentage: 43 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 57 + "True": 43 test-flag6244: - percentage: 44 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 56 + "True": 44 test-flag6245: - percentage: 45 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 55 + "True": 45 test-flag6246: - percentage: 46 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 54 + "True": 46 test-flag6247: - percentage: 47 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 53 + "True": 47 test-flag6248: - percentage: 48 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 52 + "True": 48 test-flag6249: - percentage: 49 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 51 + "True": 49 test-flag6250: - percentage: 50 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 50 + "True": 50 test-flag6251: - percentage: 51 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 49 + "True": 51 test-flag6252: - percentage: 52 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 48 + "True": 52 test-flag6253: - percentage: 53 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 47 + "True": 53 test-flag6254: - percentage: 54 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 46 + "True": 54 test-flag6255: - percentage: 55 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 45 + "True": 55 test-flag6256: - percentage: 56 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 44 + "True": 56 test-flag6257: - percentage: 57 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 43 + "True": 57 test-flag6258: - percentage: 58 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 42 + "True": 58 test-flag6259: - percentage: 59 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 41 + "True": 59 test-flag6260: - percentage: 60 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 40 + "True": 60 test-flag6261: - percentage: 61 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 39 + "True": 61 test-flag6262: - percentage: 62 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 38 + "True": 62 test-flag6263: - percentage: 63 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 37 + "True": 63 test-flag6264: - percentage: 64 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 36 + "True": 64 test-flag6265: - percentage: 65 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 35 + "True": 65 test-flag6266: - percentage: 66 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 34 + "True": 66 test-flag6267: - percentage: 67 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 33 + "True": 67 test-flag6268: - percentage: 68 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 32 + "True": 68 test-flag6269: - percentage: 69 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 31 + "True": 69 test-flag6270: - percentage: 70 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 30 + "True": 70 test-flag6271: - percentage: 71 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 29 + "True": 71 test-flag6272: - percentage: 72 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 28 + "True": 72 test-flag6273: - percentage: 73 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 27 + "True": 73 test-flag6274: - percentage: 74 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 26 + "True": 74 test-flag6275: - percentage: 75 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 25 + "True": 75 test-flag6276: - percentage: 76 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 24 + "True": 76 test-flag6277: - percentage: 77 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 23 + "True": 77 test-flag6278: - percentage: 78 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 22 + "True": 78 test-flag6279: - percentage: 79 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 21 + "True": 79 test-flag6280: - percentage: 80 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 20 + "True": 80 test-flag6281: - percentage: 81 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 19 + "True": 81 test-flag6282: - percentage: 82 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 18 + "True": 82 test-flag6283: - percentage: 83 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 17 + "True": 83 test-flag6284: - percentage: 84 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 16 + "True": 84 test-flag6285: - percentage: 85 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 15 + "True": 85 test-flag6286: - percentage: 86 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 14 + "True": 86 test-flag6287: - percentage: 87 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 13 + "True": 87 test-flag6288: - percentage: 88 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 12 + "True": 88 test-flag6289: - percentage: 89 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 11 + "True": 89 test-flag6290: - percentage: 90 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 10 + "True": 90 test-flag6291: - percentage: 91 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 9 + "True": 91 test-flag6292: - percentage: 92 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 8 + "True": 92 test-flag6293: - percentage: 93 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 7 + "True": 93 test-flag6294: - percentage: 94 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 6 + "True": 94 test-flag6295: - percentage: 95 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 5 + "True": 95 test-flag6296: - percentage: 96 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 4 + "True": 96 test-flag6297: - percentage: 97 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 3 + "True": 97 test-flag6298: - percentage: 98 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 2 + "True": 98 test-flag6299: - percentage: 99 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 1 + "True": 99 test-flag6300: - percentage: 0 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 100 + "True": 0 test-flag6301: - percentage: 1 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 99 + "True": 1 test-flag6302: - percentage: 2 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 98 + "True": 2 test-flag6303: - percentage: 3 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 97 + "True": 3 test-flag6304: - percentage: 4 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 96 + "True": 4 test-flag6305: - percentage: 5 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 95 + "True": 5 test-flag6306: - percentage: 6 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 94 + "True": 6 test-flag6307: - percentage: 7 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 93 + "True": 7 test-flag6308: - percentage: 8 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 92 + "True": 8 test-flag6309: - percentage: 9 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 91 + "True": 9 test-flag6310: - percentage: 10 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 90 + "True": 10 test-flag6311: - percentage: 11 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 89 + "True": 11 test-flag6312: - percentage: 12 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 88 + "True": 12 test-flag6313: - percentage: 13 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 87 + "True": 13 test-flag6314: - percentage: 14 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 86 + "True": 14 test-flag6315: - percentage: 15 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 85 + "True": 15 test-flag6316: - percentage: 16 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 84 + "True": 16 test-flag6317: - percentage: 17 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 83 + "True": 17 test-flag6318: - percentage: 18 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 82 + "True": 18 test-flag6319: - percentage: 19 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 81 + "True": 19 test-flag6320: - percentage: 20 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 80 + "True": 20 test-flag6321: - percentage: 21 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 79 + "True": 21 test-flag6322: - percentage: 22 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 78 + "True": 22 test-flag6323: - percentage: 23 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 77 + "True": 23 test-flag6324: - percentage: 24 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 76 + "True": 24 test-flag6325: - percentage: 25 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 75 + "True": 25 test-flag6326: - percentage: 26 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 74 + "True": 26 test-flag6327: - percentage: 27 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 73 + "True": 27 test-flag6328: - percentage: 28 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 72 + "True": 28 test-flag6329: - percentage: 29 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 71 + "True": 29 test-flag6330: - percentage: 30 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 70 + "True": 30 test-flag6331: - percentage: 31 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 69 + "True": 31 test-flag6332: - percentage: 32 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 68 + "True": 32 test-flag6333: - percentage: 33 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 67 + "True": 33 test-flag6334: - percentage: 34 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 66 + "True": 34 test-flag6335: - percentage: 35 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 65 + "True": 35 test-flag6336: - percentage: 36 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 64 + "True": 36 test-flag6337: - percentage: 37 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 63 + "True": 37 test-flag6338: - percentage: 38 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 62 + "True": 38 test-flag6339: - percentage: 39 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 61 + "True": 39 test-flag6340: - percentage: 40 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 60 + "True": 40 test-flag6341: - percentage: 41 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 59 + "True": 41 test-flag6342: - percentage: 42 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 58 + "True": 42 test-flag6343: - percentage: 43 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 57 + "True": 43 test-flag6344: - percentage: 44 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 56 + "True": 44 test-flag6345: - percentage: 45 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 55 + "True": 45 test-flag6346: - percentage: 46 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 54 + "True": 46 test-flag6347: - percentage: 47 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 53 + "True": 47 test-flag6348: - percentage: 48 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 52 + "True": 48 test-flag6349: - percentage: 49 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 51 + "True": 49 test-flag6350: - percentage: 50 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 50 + "True": 50 test-flag6351: - percentage: 51 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 49 + "True": 51 test-flag6352: - percentage: 52 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 48 + "True": 52 test-flag6353: - percentage: 53 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 47 + "True": 53 test-flag6354: - percentage: 54 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 46 + "True": 54 test-flag6355: - percentage: 55 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 45 + "True": 55 test-flag6356: - percentage: 56 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 44 + "True": 56 test-flag6357: - percentage: 57 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 43 + "True": 57 test-flag6358: - percentage: 58 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 42 + "True": 58 test-flag6359: - percentage: 59 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 41 + "True": 59 test-flag6360: - percentage: 60 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 40 + "True": 60 test-flag6361: - percentage: 61 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 39 + "True": 61 test-flag6362: - percentage: 62 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 38 + "True": 62 test-flag6363: - percentage: 63 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 37 + "True": 63 test-flag6364: - percentage: 64 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 36 + "True": 64 test-flag6365: - percentage: 65 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 35 + "True": 65 test-flag6366: - percentage: 66 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 34 + "True": 66 test-flag6367: - percentage: 67 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 33 + "True": 67 test-flag6368: - percentage: 68 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 32 + "True": 68 test-flag6369: - percentage: 69 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 31 + "True": 69 test-flag6370: - percentage: 70 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 30 + "True": 70 test-flag6371: - percentage: 71 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 29 + "True": 71 test-flag6372: - percentage: 72 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 28 + "True": 72 test-flag6373: - percentage: 73 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 27 + "True": 73 test-flag6374: - percentage: 74 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 26 + "True": 74 test-flag6375: - percentage: 75 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 25 + "True": 75 test-flag6376: - percentage: 76 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 24 + "True": 76 test-flag6377: - percentage: 77 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 23 + "True": 77 test-flag6378: - percentage: 78 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 22 + "True": 78 test-flag6379: - percentage: 79 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 21 + "True": 79 test-flag6380: - percentage: 80 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 20 + "True": 80 test-flag6381: - percentage: 81 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 19 + "True": 81 test-flag6382: - percentage: 82 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 18 + "True": 82 test-flag6383: - percentage: 83 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 17 + "True": 83 test-flag6384: - percentage: 84 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 16 + "True": 84 test-flag6385: - percentage: 85 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 15 + "True": 85 test-flag6386: - percentage: 86 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 14 + "True": 86 test-flag6387: - percentage: 87 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 13 + "True": 87 test-flag6388: - percentage: 88 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 12 + "True": 88 test-flag6389: - percentage: 89 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 11 + "True": 89 test-flag6390: - percentage: 90 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 10 + "True": 90 test-flag6391: - percentage: 91 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 9 + "True": 91 test-flag6392: - percentage: 92 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 8 + "True": 92 test-flag6393: - percentage: 93 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 7 + "True": 93 test-flag6394: - percentage: 94 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 6 + "True": 94 test-flag6395: - percentage: 95 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 5 + "True": 95 test-flag6396: - percentage: 96 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 4 + "True": 96 test-flag6397: - percentage: 97 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 3 + "True": 97 test-flag6398: - percentage: 98 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 2 + "True": 98 test-flag6399: - percentage: 99 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 1 + "True": 99 test-flag6400: - percentage: 0 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 100 + "True": 0 test-flag6401: - percentage: 1 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 99 + "True": 1 test-flag6402: - percentage: 2 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 98 + "True": 2 test-flag6403: - percentage: 3 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 97 + "True": 3 test-flag6404: - percentage: 4 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 96 + "True": 4 test-flag6405: - percentage: 5 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 95 + "True": 5 test-flag6406: - percentage: 6 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 94 + "True": 6 test-flag6407: - percentage: 7 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 93 + "True": 7 test-flag6408: - percentage: 8 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 92 + "True": 8 test-flag6409: - percentage: 9 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 91 + "True": 9 test-flag6410: - percentage: 10 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 90 + "True": 10 test-flag6411: - percentage: 11 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 89 + "True": 11 test-flag6412: - percentage: 12 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 88 + "True": 12 test-flag6413: - percentage: 13 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 87 + "True": 13 test-flag6414: - percentage: 14 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 86 + "True": 14 test-flag6415: - percentage: 15 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 85 + "True": 15 test-flag6416: - percentage: 16 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 84 + "True": 16 test-flag6417: - percentage: 17 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 83 + "True": 17 test-flag6418: - percentage: 18 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 82 + "True": 18 test-flag6419: - percentage: 19 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 81 + "True": 19 test-flag6420: - percentage: 20 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 80 + "True": 20 test-flag6421: - percentage: 21 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 79 + "True": 21 test-flag6422: - percentage: 22 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 78 + "True": 22 test-flag6423: - percentage: 23 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 77 + "True": 23 test-flag6424: - percentage: 24 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 76 + "True": 24 test-flag6425: - percentage: 25 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 75 + "True": 25 test-flag6426: - percentage: 26 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 74 + "True": 26 test-flag6427: - percentage: 27 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 73 + "True": 27 test-flag6428: - percentage: 28 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 72 + "True": 28 test-flag6429: - percentage: 29 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 71 + "True": 29 test-flag6430: - percentage: 30 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 70 + "True": 30 test-flag6431: - percentage: 31 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 69 + "True": 31 test-flag6432: - percentage: 32 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 68 + "True": 32 test-flag6433: - percentage: 33 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 67 + "True": 33 test-flag6434: - percentage: 34 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 66 + "True": 34 test-flag6435: - percentage: 35 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 65 + "True": 35 test-flag6436: - percentage: 36 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 64 + "True": 36 test-flag6437: - percentage: 37 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 63 + "True": 37 test-flag6438: - percentage: 38 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 62 + "True": 38 test-flag6439: - percentage: 39 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 61 + "True": 39 test-flag6440: - percentage: 40 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 60 + "True": 40 test-flag6441: - percentage: 41 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 59 + "True": 41 test-flag6442: - percentage: 42 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 58 + "True": 42 test-flag6443: - percentage: 43 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 57 + "True": 43 test-flag6444: - percentage: 44 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 56 + "True": 44 test-flag6445: - percentage: 45 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 55 + "True": 45 test-flag6446: - percentage: 46 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 54 + "True": 46 test-flag6447: - percentage: 47 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 53 + "True": 47 test-flag6448: - percentage: 48 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 52 + "True": 48 test-flag6449: - percentage: 49 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 51 + "True": 49 test-flag6450: - percentage: 50 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 50 + "True": 50 test-flag6451: - percentage: 51 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 49 + "True": 51 test-flag6452: - percentage: 52 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 48 + "True": 52 test-flag6453: - percentage: 53 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 47 + "True": 53 test-flag6454: - percentage: 54 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 46 + "True": 54 test-flag6455: - percentage: 55 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 45 + "True": 55 test-flag6456: - percentage: 56 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 44 + "True": 56 test-flag6457: - percentage: 57 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 43 + "True": 57 test-flag6458: - percentage: 58 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 42 + "True": 58 test-flag6459: - percentage: 59 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 41 + "True": 59 test-flag6460: - percentage: 60 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 40 + "True": 60 test-flag6461: - percentage: 61 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 39 + "True": 61 test-flag6462: - percentage: 62 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 38 + "True": 62 test-flag6463: - percentage: 63 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 37 + "True": 63 test-flag6464: - percentage: 64 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 36 + "True": 64 test-flag6465: - percentage: 65 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 35 + "True": 65 test-flag6466: - percentage: 66 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 34 + "True": 66 test-flag6467: - percentage: 67 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 33 + "True": 67 test-flag6468: - percentage: 68 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 32 + "True": 68 test-flag6469: - percentage: 69 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 31 + "True": 69 test-flag6470: - percentage: 70 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 30 + "True": 70 test-flag6471: - percentage: 71 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 29 + "True": 71 test-flag6472: - percentage: 72 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 28 + "True": 72 test-flag6473: - percentage: 73 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 27 + "True": 73 test-flag6474: - percentage: 74 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 26 + "True": 74 test-flag6475: - percentage: 75 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 25 + "True": 75 test-flag6476: - percentage: 76 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 24 + "True": 76 test-flag6477: - percentage: 77 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 23 + "True": 77 test-flag6478: - percentage: 78 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 22 + "True": 78 test-flag6479: - percentage: 79 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 21 + "True": 79 test-flag6480: - percentage: 80 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 20 + "True": 80 test-flag6481: - percentage: 81 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 19 + "True": 81 test-flag6482: - percentage: 82 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 18 + "True": 82 test-flag6483: - percentage: 83 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 17 + "True": 83 test-flag6484: - percentage: 84 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 16 + "True": 84 test-flag6485: - percentage: 85 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 15 + "True": 85 test-flag6486: - percentage: 86 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 14 + "True": 86 test-flag6487: - percentage: 87 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 13 + "True": 87 test-flag6488: - percentage: 88 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 12 + "True": 88 test-flag6489: - percentage: 89 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 11 + "True": 89 test-flag6490: - percentage: 90 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 10 + "True": 90 test-flag6491: - percentage: 91 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 9 + "True": 91 test-flag6492: - percentage: 92 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 8 + "True": 92 test-flag6493: - percentage: 93 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 7 + "True": 93 test-flag6494: - percentage: 94 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 6 + "True": 94 test-flag6495: - percentage: 95 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 5 + "True": 95 test-flag6496: - percentage: 96 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 4 + "True": 96 test-flag6497: - percentage: 97 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 3 + "True": 97 test-flag6498: - percentage: 98 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 2 + "True": 98 test-flag6499: - percentage: 99 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 1 + "True": 99 test-flag6500: - percentage: 0 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 100 + "True": 0 test-flag6501: - percentage: 1 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 99 + "True": 1 test-flag6502: - percentage: 2 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 98 + "True": 2 test-flag6503: - percentage: 3 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 97 + "True": 3 test-flag6504: - percentage: 4 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 96 + "True": 4 test-flag6505: - percentage: 5 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 95 + "True": 5 test-flag6506: - percentage: 6 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 94 + "True": 6 test-flag6507: - percentage: 7 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 93 + "True": 7 test-flag6508: - percentage: 8 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 92 + "True": 8 test-flag6509: - percentage: 9 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 91 + "True": 9 test-flag6510: - percentage: 10 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 90 + "True": 10 test-flag6511: - percentage: 11 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 89 + "True": 11 test-flag6512: - percentage: 12 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 88 + "True": 12 test-flag6513: - percentage: 13 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 87 + "True": 13 test-flag6514: - percentage: 14 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 86 + "True": 14 test-flag6515: - percentage: 15 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 85 + "True": 15 test-flag6516: - percentage: 16 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 84 + "True": 16 test-flag6517: - percentage: 17 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 83 + "True": 17 test-flag6518: - percentage: 18 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 82 + "True": 18 test-flag6519: - percentage: 19 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 81 + "True": 19 test-flag6520: - percentage: 20 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 80 + "True": 20 test-flag6521: - percentage: 21 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 79 + "True": 21 test-flag6522: - percentage: 22 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 78 + "True": 22 test-flag6523: - percentage: 23 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 77 + "True": 23 test-flag6524: - percentage: 24 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 76 + "True": 24 test-flag6525: - percentage: 25 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 75 + "True": 25 test-flag6526: - percentage: 26 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 74 + "True": 26 test-flag6527: - percentage: 27 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 73 + "True": 27 test-flag6528: - percentage: 28 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 72 + "True": 28 test-flag6529: - percentage: 29 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 71 + "True": 29 test-flag6530: - percentage: 30 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 70 + "True": 30 test-flag6531: - percentage: 31 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 69 + "True": 31 test-flag6532: - percentage: 32 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 68 + "True": 32 test-flag6533: - percentage: 33 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 67 + "True": 33 test-flag6534: - percentage: 34 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 66 + "True": 34 test-flag6535: - percentage: 35 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 65 + "True": 35 test-flag6536: - percentage: 36 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 64 + "True": 36 test-flag6537: - percentage: 37 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 63 + "True": 37 test-flag6538: - percentage: 38 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 62 + "True": 38 test-flag6539: - percentage: 39 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 61 + "True": 39 test-flag6540: - percentage: 40 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 60 + "True": 40 test-flag6541: - percentage: 41 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 59 + "True": 41 test-flag6542: - percentage: 42 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 58 + "True": 42 test-flag6543: - percentage: 43 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 57 + "True": 43 test-flag6544: - percentage: 44 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 56 + "True": 44 test-flag6545: - percentage: 45 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 55 + "True": 45 test-flag6546: - percentage: 46 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 54 + "True": 46 test-flag6547: - percentage: 47 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 53 + "True": 47 test-flag6548: - percentage: 48 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 52 + "True": 48 test-flag6549: - percentage: 49 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 51 + "True": 49 test-flag6550: - percentage: 50 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 50 + "True": 50 test-flag6551: - percentage: 51 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 49 + "True": 51 test-flag6552: - percentage: 52 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 48 + "True": 52 test-flag6553: - percentage: 53 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 47 + "True": 53 test-flag6554: - percentage: 54 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 46 + "True": 54 test-flag6555: - percentage: 55 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 45 + "True": 55 test-flag6556: - percentage: 56 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 44 + "True": 56 test-flag6557: - percentage: 57 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 43 + "True": 57 test-flag6558: - percentage: 58 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 42 + "True": 58 test-flag6559: - percentage: 59 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 41 + "True": 59 test-flag6560: - percentage: 60 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 40 + "True": 60 test-flag6561: - percentage: 61 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 39 + "True": 61 test-flag6562: - percentage: 62 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 38 + "True": 62 test-flag6563: - percentage: 63 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 37 + "True": 63 test-flag6564: - percentage: 64 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 36 + "True": 64 test-flag6565: - percentage: 65 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 35 + "True": 65 test-flag6566: - percentage: 66 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 34 + "True": 66 test-flag6567: - percentage: 67 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 33 + "True": 67 test-flag6568: - percentage: 68 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 32 + "True": 68 test-flag6569: - percentage: 69 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 31 + "True": 69 test-flag6570: - percentage: 70 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 30 + "True": 70 test-flag6571: - percentage: 71 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 29 + "True": 71 test-flag6572: - percentage: 72 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 28 + "True": 72 test-flag6573: - percentage: 73 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 27 + "True": 73 test-flag6574: - percentage: 74 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 26 + "True": 74 test-flag6575: - percentage: 75 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 25 + "True": 75 test-flag6576: - percentage: 76 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 24 + "True": 76 test-flag6577: - percentage: 77 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 23 + "True": 77 test-flag6578: - percentage: 78 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 22 + "True": 78 test-flag6579: - percentage: 79 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 21 + "True": 79 test-flag6580: - percentage: 80 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 20 + "True": 80 test-flag6581: - percentage: 81 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 19 + "True": 81 test-flag6582: - percentage: 82 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 18 + "True": 82 test-flag6583: - percentage: 83 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 17 + "True": 83 test-flag6584: - percentage: 84 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 16 + "True": 84 test-flag6585: - percentage: 85 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 15 + "True": 85 test-flag6586: - percentage: 86 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 14 + "True": 86 test-flag6587: - percentage: 87 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 13 + "True": 87 test-flag6588: - percentage: 88 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 12 + "True": 88 test-flag6589: - percentage: 89 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 11 + "True": 89 test-flag6590: - percentage: 90 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 10 + "True": 90 test-flag6591: - percentage: 91 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 9 + "True": 91 test-flag6592: - percentage: 92 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 8 + "True": 92 test-flag6593: - percentage: 93 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 7 + "True": 93 test-flag6594: - percentage: 94 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 6 + "True": 94 test-flag6595: - percentage: 95 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 5 + "True": 95 test-flag6596: - percentage: 96 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 4 + "True": 96 test-flag6597: - percentage: 97 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 3 + "True": 97 test-flag6598: - percentage: 98 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 2 + "True": 98 test-flag6599: - percentage: 99 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 1 + "True": 99 test-flag6600: - percentage: 0 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 100 + "True": 0 test-flag6601: - percentage: 1 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 99 + "True": 1 test-flag6602: - percentage: 2 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 98 + "True": 2 test-flag6603: - percentage: 3 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 97 + "True": 3 test-flag6604: - percentage: 4 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 96 + "True": 4 test-flag6605: - percentage: 5 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 95 + "True": 5 test-flag6606: - percentage: 6 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 94 + "True": 6 test-flag6607: - percentage: 7 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 93 + "True": 7 test-flag6608: - percentage: 8 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 92 + "True": 8 test-flag6609: - percentage: 9 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 91 + "True": 9 test-flag6610: - percentage: 10 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 90 + "True": 10 test-flag6611: - percentage: 11 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 89 + "True": 11 test-flag6612: - percentage: 12 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 88 + "True": 12 test-flag6613: - percentage: 13 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 87 + "True": 13 test-flag6614: - percentage: 14 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 86 + "True": 14 test-flag6615: - percentage: 15 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 85 + "True": 15 test-flag6616: - percentage: 16 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 84 + "True": 16 test-flag6617: - percentage: 17 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 83 + "True": 17 test-flag6618: - percentage: 18 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 82 + "True": 18 test-flag6619: - percentage: 19 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 81 + "True": 19 test-flag6620: - percentage: 20 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 80 + "True": 20 test-flag6621: - percentage: 21 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 79 + "True": 21 test-flag6622: - percentage: 22 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 78 + "True": 22 test-flag6623: - percentage: 23 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 77 + "True": 23 test-flag6624: - percentage: 24 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 76 + "True": 24 test-flag6625: - percentage: 25 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 75 + "True": 25 test-flag6626: - percentage: 26 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 74 + "True": 26 test-flag6627: - percentage: 27 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 73 + "True": 27 test-flag6628: - percentage: 28 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 72 + "True": 28 test-flag6629: - percentage: 29 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 71 + "True": 29 test-flag6630: - percentage: 30 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 70 + "True": 30 test-flag6631: - percentage: 31 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 69 + "True": 31 test-flag6632: - percentage: 32 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 68 + "True": 32 test-flag6633: - percentage: 33 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 67 + "True": 33 test-flag6634: - percentage: 34 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 66 + "True": 34 test-flag6635: - percentage: 35 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 65 + "True": 35 test-flag6636: - percentage: 36 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 64 + "True": 36 test-flag6637: - percentage: 37 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 63 + "True": 37 test-flag6638: - percentage: 38 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 62 + "True": 38 test-flag6639: - percentage: 39 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 61 + "True": 39 test-flag6640: - percentage: 40 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 60 + "True": 40 test-flag6641: - percentage: 41 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 59 + "True": 41 test-flag6642: - percentage: 42 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 58 + "True": 42 test-flag6643: - percentage: 43 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 57 + "True": 43 test-flag6644: - percentage: 44 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 56 + "True": 44 test-flag6645: - percentage: 45 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 55 + "True": 45 test-flag6646: - percentage: 46 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 54 + "True": 46 test-flag6647: - percentage: 47 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 53 + "True": 47 test-flag6648: - percentage: 48 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 52 + "True": 48 test-flag6649: - percentage: 49 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 51 + "True": 49 test-flag6650: - percentage: 50 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 50 + "True": 50 test-flag6651: - percentage: 51 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 49 + "True": 51 test-flag6652: - percentage: 52 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 48 + "True": 52 test-flag6653: - percentage: 53 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 47 + "True": 53 test-flag6654: - percentage: 54 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 46 + "True": 54 test-flag6655: - percentage: 55 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 45 + "True": 55 test-flag6656: - percentage: 56 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 44 + "True": 56 test-flag6657: - percentage: 57 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 43 + "True": 57 test-flag6658: - percentage: 58 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 42 + "True": 58 test-flag6659: - percentage: 59 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 41 + "True": 59 test-flag6660: - percentage: 60 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 40 + "True": 60 test-flag6661: - percentage: 61 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 39 + "True": 61 test-flag6662: - percentage: 62 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 38 + "True": 62 test-flag6663: - percentage: 63 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 37 + "True": 63 test-flag6664: - percentage: 64 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 36 + "True": 64 test-flag6665: - percentage: 65 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 35 + "True": 65 test-flag6666: - percentage: 66 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 34 + "True": 66 test-flag6667: - percentage: 67 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 33 + "True": 67 test-flag6668: - percentage: 68 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 32 + "True": 68 test-flag6669: - percentage: 69 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 31 + "True": 69 test-flag6670: - percentage: 70 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 30 + "True": 70 test-flag6671: - percentage: 71 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 29 + "True": 71 test-flag6672: - percentage: 72 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 28 + "True": 72 test-flag6673: - percentage: 73 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 27 + "True": 73 test-flag6674: - percentage: 74 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 26 + "True": 74 test-flag6675: - percentage: 75 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 25 + "True": 75 test-flag6676: - percentage: 76 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 24 + "True": 76 test-flag6677: - percentage: 77 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 23 + "True": 77 test-flag6678: - percentage: 78 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 22 + "True": 78 test-flag6679: - percentage: 79 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 21 + "True": 79 test-flag6680: - percentage: 80 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 20 + "True": 80 test-flag6681: - percentage: 81 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 19 + "True": 81 test-flag6682: - percentage: 82 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 18 + "True": 82 test-flag6683: - percentage: 83 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 17 + "True": 83 test-flag6684: - percentage: 84 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 16 + "True": 84 test-flag6685: - percentage: 85 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 15 + "True": 85 test-flag6686: - percentage: 86 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 14 + "True": 86 test-flag6687: - percentage: 87 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 13 + "True": 87 test-flag6688: - percentage: 88 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 12 + "True": 88 test-flag6689: - percentage: 89 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 11 + "True": 89 test-flag6690: - percentage: 90 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 10 + "True": 90 test-flag6691: - percentage: 91 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 9 + "True": 91 test-flag6692: - percentage: 92 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 8 + "True": 92 test-flag6693: - percentage: 93 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 7 + "True": 93 test-flag6694: - percentage: 94 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 6 + "True": 94 test-flag6695: - percentage: 95 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 5 + "True": 95 test-flag6696: - percentage: 96 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 4 + "True": 96 test-flag6697: - percentage: 97 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 3 + "True": 97 test-flag6698: - percentage: 98 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 2 + "True": 98 test-flag6699: - percentage: 99 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 1 + "True": 99 test-flag6700: - percentage: 0 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 100 + "True": 0 test-flag6701: - percentage: 1 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 99 + "True": 1 test-flag6702: - percentage: 2 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 98 + "True": 2 test-flag6703: - percentage: 3 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 97 + "True": 3 test-flag6704: - percentage: 4 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 96 + "True": 4 test-flag6705: - percentage: 5 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 95 + "True": 5 test-flag6706: - percentage: 6 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 94 + "True": 6 test-flag6707: - percentage: 7 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 93 + "True": 7 test-flag6708: - percentage: 8 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 92 + "True": 8 test-flag6709: - percentage: 9 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 91 + "True": 9 test-flag6710: - percentage: 10 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 90 + "True": 10 test-flag6711: - percentage: 11 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 89 + "True": 11 test-flag6712: - percentage: 12 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 88 + "True": 12 test-flag6713: - percentage: 13 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 87 + "True": 13 test-flag6714: - percentage: 14 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 86 + "True": 14 test-flag6715: - percentage: 15 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 85 + "True": 15 test-flag6716: - percentage: 16 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 84 + "True": 16 test-flag6717: - percentage: 17 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 83 + "True": 17 test-flag6718: - percentage: 18 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 82 + "True": 18 test-flag6719: - percentage: 19 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 81 + "True": 19 test-flag6720: - percentage: 20 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 80 + "True": 20 test-flag6721: - percentage: 21 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 79 + "True": 21 test-flag6722: - percentage: 22 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 78 + "True": 22 test-flag6723: - percentage: 23 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 77 + "True": 23 test-flag6724: - percentage: 24 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 76 + "True": 24 test-flag6725: - percentage: 25 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 75 + "True": 25 test-flag6726: - percentage: 26 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 74 + "True": 26 test-flag6727: - percentage: 27 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 73 + "True": 27 test-flag6728: - percentage: 28 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 72 + "True": 28 test-flag6729: - percentage: 29 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 71 + "True": 29 test-flag6730: - percentage: 30 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 70 + "True": 30 test-flag6731: - percentage: 31 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 69 + "True": 31 test-flag6732: - percentage: 32 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 68 + "True": 32 test-flag6733: - percentage: 33 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 67 + "True": 33 test-flag6734: - percentage: 34 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 66 + "True": 34 test-flag6735: - percentage: 35 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 65 + "True": 35 test-flag6736: - percentage: 36 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 64 + "True": 36 test-flag6737: - percentage: 37 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 63 + "True": 37 test-flag6738: - percentage: 38 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 62 + "True": 38 test-flag6739: - percentage: 39 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 61 + "True": 39 test-flag6740: - percentage: 40 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 60 + "True": 40 test-flag6741: - percentage: 41 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 59 + "True": 41 test-flag6742: - percentage: 42 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 58 + "True": 42 test-flag6743: - percentage: 43 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 57 + "True": 43 test-flag6744: - percentage: 44 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 56 + "True": 44 test-flag6745: - percentage: 45 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 55 + "True": 45 test-flag6746: - percentage: 46 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 54 + "True": 46 test-flag6747: - percentage: 47 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 53 + "True": 47 test-flag6748: - percentage: 48 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 52 + "True": 48 test-flag6749: - percentage: 49 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 51 + "True": 49 test-flag6750: - percentage: 50 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 50 + "True": 50 test-flag6751: - percentage: 51 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 49 + "True": 51 test-flag6752: - percentage: 52 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 48 + "True": 52 test-flag6753: - percentage: 53 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 47 + "True": 53 test-flag6754: - percentage: 54 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 46 + "True": 54 test-flag6755: - percentage: 55 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 45 + "True": 55 test-flag6756: - percentage: 56 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 44 + "True": 56 test-flag6757: - percentage: 57 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 43 + "True": 57 test-flag6758: - percentage: 58 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 42 + "True": 58 test-flag6759: - percentage: 59 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 41 + "True": 59 test-flag6760: - percentage: 60 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 40 + "True": 60 test-flag6761: - percentage: 61 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 39 + "True": 61 test-flag6762: - percentage: 62 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 38 + "True": 62 test-flag6763: - percentage: 63 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 37 + "True": 63 test-flag6764: - percentage: 64 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 36 + "True": 64 test-flag6765: - percentage: 65 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 35 + "True": 65 test-flag6766: - percentage: 66 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 34 + "True": 66 test-flag6767: - percentage: 67 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 33 + "True": 67 test-flag6768: - percentage: 68 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 32 + "True": 68 test-flag6769: - percentage: 69 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 31 + "True": 69 test-flag6770: - percentage: 70 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 30 + "True": 70 test-flag6771: - percentage: 71 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 29 + "True": 71 test-flag6772: - percentage: 72 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 28 + "True": 72 test-flag6773: - percentage: 73 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 27 + "True": 73 test-flag6774: - percentage: 74 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 26 + "True": 74 test-flag6775: - percentage: 75 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 25 + "True": 75 test-flag6776: - percentage: 76 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 24 + "True": 76 test-flag6777: - percentage: 77 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 23 + "True": 77 test-flag6778: - percentage: 78 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 22 + "True": 78 test-flag6779: - percentage: 79 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 21 + "True": 79 test-flag6780: - percentage: 80 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 20 + "True": 80 test-flag6781: - percentage: 81 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 19 + "True": 81 test-flag6782: - percentage: 82 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 18 + "True": 82 test-flag6783: - percentage: 83 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 17 + "True": 83 test-flag6784: - percentage: 84 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 16 + "True": 84 test-flag6785: - percentage: 85 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 15 + "True": 85 test-flag6786: - percentage: 86 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 14 + "True": 86 test-flag6787: - percentage: 87 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 13 + "True": 87 test-flag6788: - percentage: 88 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 12 + "True": 88 test-flag6789: - percentage: 89 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 11 + "True": 89 test-flag6790: - percentage: 90 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 10 + "True": 90 test-flag6791: - percentage: 91 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 9 + "True": 91 test-flag6792: - percentage: 92 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 8 + "True": 92 test-flag6793: - percentage: 93 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 7 + "True": 93 test-flag6794: - percentage: 94 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 6 + "True": 94 test-flag6795: - percentage: 95 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 5 + "True": 95 test-flag6796: - percentage: 96 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 4 + "True": 96 test-flag6797: - percentage: 97 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 3 + "True": 97 test-flag6798: - percentage: 98 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 2 + "True": 98 test-flag6799: - percentage: 99 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 1 + "True": 99 test-flag6800: - percentage: 0 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 100 + "True": 0 test-flag6801: - percentage: 1 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 99 + "True": 1 test-flag6802: - percentage: 2 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 98 + "True": 2 test-flag6803: - percentage: 3 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 97 + "True": 3 test-flag6804: - percentage: 4 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 96 + "True": 4 test-flag6805: - percentage: 5 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 95 + "True": 5 test-flag6806: - percentage: 6 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 94 + "True": 6 test-flag6807: - percentage: 7 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 93 + "True": 7 test-flag6808: - percentage: 8 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 92 + "True": 8 test-flag6809: - percentage: 9 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 91 + "True": 9 test-flag6810: - percentage: 10 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 90 + "True": 10 test-flag6811: - percentage: 11 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 89 + "True": 11 test-flag6812: - percentage: 12 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 88 + "True": 12 test-flag6813: - percentage: 13 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 87 + "True": 13 test-flag6814: - percentage: 14 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 86 + "True": 14 test-flag6815: - percentage: 15 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 85 + "True": 15 test-flag6816: - percentage: 16 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 84 + "True": 16 test-flag6817: - percentage: 17 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 83 + "True": 17 test-flag6818: - percentage: 18 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 82 + "True": 18 test-flag6819: - percentage: 19 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 81 + "True": 19 test-flag6820: - percentage: 20 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 80 + "True": 20 test-flag6821: - percentage: 21 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 79 + "True": 21 test-flag6822: - percentage: 22 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 78 + "True": 22 test-flag6823: - percentage: 23 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 77 + "True": 23 test-flag6824: - percentage: 24 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 76 + "True": 24 test-flag6825: - percentage: 25 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 75 + "True": 25 test-flag6826: - percentage: 26 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 74 + "True": 26 test-flag6827: - percentage: 27 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 73 + "True": 27 test-flag6828: - percentage: 28 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 72 + "True": 28 test-flag6829: - percentage: 29 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 71 + "True": 29 test-flag6830: - percentage: 30 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 70 + "True": 30 test-flag6831: - percentage: 31 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 69 + "True": 31 test-flag6832: - percentage: 32 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 68 + "True": 32 test-flag6833: - percentage: 33 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 67 + "True": 33 test-flag6834: - percentage: 34 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 66 + "True": 34 test-flag6835: - percentage: 35 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 65 + "True": 35 test-flag6836: - percentage: 36 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 64 + "True": 36 test-flag6837: - percentage: 37 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 63 + "True": 37 test-flag6838: - percentage: 38 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 62 + "True": 38 test-flag6839: - percentage: 39 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 61 + "True": 39 test-flag6840: - percentage: 40 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 60 + "True": 40 test-flag6841: - percentage: 41 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 59 + "True": 41 test-flag6842: - percentage: 42 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 58 + "True": 42 test-flag6843: - percentage: 43 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 57 + "True": 43 test-flag6844: - percentage: 44 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 56 + "True": 44 test-flag6845: - percentage: 45 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 55 + "True": 45 test-flag6846: - percentage: 46 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 54 + "True": 46 test-flag6847: - percentage: 47 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 53 + "True": 47 test-flag6848: - percentage: 48 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 52 + "True": 48 test-flag6849: - percentage: 49 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 51 + "True": 49 test-flag6850: - percentage: 50 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 50 + "True": 50 test-flag6851: - percentage: 51 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 49 + "True": 51 test-flag6852: - percentage: 52 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 48 + "True": 52 test-flag6853: - percentage: 53 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 47 + "True": 53 test-flag6854: - percentage: 54 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 46 + "True": 54 test-flag6855: - percentage: 55 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 45 + "True": 55 test-flag6856: - percentage: 56 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 44 + "True": 56 test-flag6857: - percentage: 57 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 43 + "True": 57 test-flag6858: - percentage: 58 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 42 + "True": 58 test-flag6859: - percentage: 59 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 41 + "True": 59 test-flag6860: - percentage: 60 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 40 + "True": 60 test-flag6861: - percentage: 61 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 39 + "True": 61 test-flag6862: - percentage: 62 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 38 + "True": 62 test-flag6863: - percentage: 63 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 37 + "True": 63 test-flag6864: - percentage: 64 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 36 + "True": 64 test-flag6865: - percentage: 65 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 35 + "True": 65 test-flag6866: - percentage: 66 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 34 + "True": 66 test-flag6867: - percentage: 67 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 33 + "True": 67 test-flag6868: - percentage: 68 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 32 + "True": 68 test-flag6869: - percentage: 69 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 31 + "True": 69 test-flag6870: - percentage: 70 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 30 + "True": 70 test-flag6871: - percentage: 71 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 29 + "True": 71 test-flag6872: - percentage: 72 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 28 + "True": 72 test-flag6873: - percentage: 73 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 27 + "True": 73 test-flag6874: - percentage: 74 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 26 + "True": 74 test-flag6875: - percentage: 75 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 25 + "True": 75 test-flag6876: - percentage: 76 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 24 + "True": 76 test-flag6877: - percentage: 77 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 23 + "True": 77 test-flag6878: - percentage: 78 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 22 + "True": 78 test-flag6879: - percentage: 79 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 21 + "True": 79 test-flag6880: - percentage: 80 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 20 + "True": 80 test-flag6881: - percentage: 81 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 19 + "True": 81 test-flag6882: - percentage: 82 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 18 + "True": 82 test-flag6883: - percentage: 83 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 17 + "True": 83 test-flag6884: - percentage: 84 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 16 + "True": 84 test-flag6885: - percentage: 85 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 15 + "True": 85 test-flag6886: - percentage: 86 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 14 + "True": 86 test-flag6887: - percentage: 87 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 13 + "True": 87 test-flag6888: - percentage: 88 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 12 + "True": 88 test-flag6889: - percentage: 89 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 11 + "True": 89 test-flag6890: - percentage: 90 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 10 + "True": 90 test-flag6891: - percentage: 91 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 9 + "True": 91 test-flag6892: - percentage: 92 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 8 + "True": 92 test-flag6893: - percentage: 93 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 7 + "True": 93 test-flag6894: - percentage: 94 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 6 + "True": 94 test-flag6895: - percentage: 95 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 5 + "True": 95 test-flag6896: - percentage: 96 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 4 + "True": 96 test-flag6897: - percentage: 97 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 3 + "True": 97 test-flag6898: - percentage: 98 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 2 + "True": 98 test-flag6899: - percentage: 99 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 1 + "True": 99 test-flag6900: - percentage: 0 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 100 + "True": 0 test-flag6901: - percentage: 1 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 99 + "True": 1 test-flag6902: - percentage: 2 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 98 + "True": 2 test-flag6903: - percentage: 3 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 97 + "True": 3 test-flag6904: - percentage: 4 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 96 + "True": 4 test-flag6905: - percentage: 5 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 95 + "True": 5 test-flag6906: - percentage: 6 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 94 + "True": 6 test-flag6907: - percentage: 7 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 93 + "True": 7 test-flag6908: - percentage: 8 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 92 + "True": 8 test-flag6909: - percentage: 9 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 91 + "True": 9 test-flag6910: - percentage: 10 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 90 + "True": 10 test-flag6911: - percentage: 11 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 89 + "True": 11 test-flag6912: - percentage: 12 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 88 + "True": 12 test-flag6913: - percentage: 13 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 87 + "True": 13 test-flag6914: - percentage: 14 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 86 + "True": 14 test-flag6915: - percentage: 15 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 85 + "True": 15 test-flag6916: - percentage: 16 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 84 + "True": 16 test-flag6917: - percentage: 17 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 83 + "True": 17 test-flag6918: - percentage: 18 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 82 + "True": 18 test-flag6919: - percentage: 19 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 81 + "True": 19 test-flag6920: - percentage: 20 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 80 + "True": 20 test-flag6921: - percentage: 21 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 79 + "True": 21 test-flag6922: - percentage: 22 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 78 + "True": 22 test-flag6923: - percentage: 23 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 77 + "True": 23 test-flag6924: - percentage: 24 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 76 + "True": 24 test-flag6925: - percentage: 25 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 75 + "True": 25 test-flag6926: - percentage: 26 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 74 + "True": 26 test-flag6927: - percentage: 27 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 73 + "True": 27 test-flag6928: - percentage: 28 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 72 + "True": 28 test-flag6929: - percentage: 29 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 71 + "True": 29 test-flag6930: - percentage: 30 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 70 + "True": 30 test-flag6931: - percentage: 31 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 69 + "True": 31 test-flag6932: - percentage: 32 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 68 + "True": 32 test-flag6933: - percentage: 33 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 67 + "True": 33 test-flag6934: - percentage: 34 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 66 + "True": 34 test-flag6935: - percentage: 35 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 65 + "True": 35 test-flag6936: - percentage: 36 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 64 + "True": 36 test-flag6937: - percentage: 37 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 63 + "True": 37 test-flag6938: - percentage: 38 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 62 + "True": 38 test-flag6939: - percentage: 39 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 61 + "True": 39 test-flag6940: - percentage: 40 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 60 + "True": 40 test-flag6941: - percentage: 41 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 59 + "True": 41 test-flag6942: - percentage: 42 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 58 + "True": 42 test-flag6943: - percentage: 43 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 57 + "True": 43 test-flag6944: - percentage: 44 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 56 + "True": 44 test-flag6945: - percentage: 45 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 55 + "True": 45 test-flag6946: - percentage: 46 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 54 + "True": 46 test-flag6947: - percentage: 47 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 53 + "True": 47 test-flag6948: - percentage: 48 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 52 + "True": 48 test-flag6949: - percentage: 49 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 51 + "True": 49 test-flag6950: - percentage: 50 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 50 + "True": 50 test-flag6951: - percentage: 51 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 49 + "True": 51 test-flag6952: - percentage: 52 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 48 + "True": 52 test-flag6953: - percentage: 53 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 47 + "True": 53 test-flag6954: - percentage: 54 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 46 + "True": 54 test-flag6955: - percentage: 55 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 45 + "True": 55 test-flag6956: - percentage: 56 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 44 + "True": 56 test-flag6957: - percentage: 57 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 43 + "True": 57 test-flag6958: - percentage: 58 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 42 + "True": 58 test-flag6959: - percentage: 59 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 41 + "True": 59 test-flag6960: - percentage: 60 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 40 + "True": 60 test-flag6961: - percentage: 61 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 39 + "True": 61 test-flag6962: - percentage: 62 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 38 + "True": 62 test-flag6963: - percentage: 63 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 37 + "True": 63 test-flag6964: - percentage: 64 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 36 + "True": 64 test-flag6965: - percentage: 65 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 35 + "True": 65 test-flag6966: - percentage: 66 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 34 + "True": 66 test-flag6967: - percentage: 67 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 33 + "True": 67 test-flag6968: - percentage: 68 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 32 + "True": 68 test-flag6969: - percentage: 69 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 31 + "True": 69 test-flag6970: - percentage: 70 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 30 + "True": 70 test-flag6971: - percentage: 71 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 29 + "True": 71 test-flag6972: - percentage: 72 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 28 + "True": 72 test-flag6973: - percentage: 73 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 27 + "True": 73 test-flag6974: - percentage: 74 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 26 + "True": 74 test-flag6975: - percentage: 75 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 25 + "True": 75 test-flag6976: - percentage: 76 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 24 + "True": 76 test-flag6977: - percentage: 77 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 23 + "True": 77 test-flag6978: - percentage: 78 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 22 + "True": 78 test-flag6979: - percentage: 79 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 21 + "True": 79 test-flag6980: - percentage: 80 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 20 + "True": 80 test-flag6981: - percentage: 81 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 19 + "True": 81 test-flag6982: - percentage: 82 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 18 + "True": 82 test-flag6983: - percentage: 83 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 17 + "True": 83 test-flag6984: - percentage: 84 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 16 + "True": 84 test-flag6985: - percentage: 85 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 15 + "True": 85 test-flag6986: - percentage: 86 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 14 + "True": 86 test-flag6987: - percentage: 87 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 13 + "True": 87 test-flag6988: - percentage: 88 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 12 + "True": 88 test-flag6989: - percentage: 89 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 11 + "True": 89 test-flag6990: - percentage: 90 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 10 + "True": 90 test-flag6991: - percentage: 91 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 9 + "True": 91 test-flag6992: - percentage: 92 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 8 + "True": 92 test-flag6993: - percentage: 93 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 7 + "True": 93 test-flag6994: - percentage: 94 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 6 + "True": 94 test-flag6995: - percentage: 95 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 5 + "True": 95 test-flag6996: - percentage: 96 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 4 + "True": 96 test-flag6997: - percentage: 97 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 3 + "True": 97 test-flag6998: - percentage: 98 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 2 + "True": 98 test-flag6999: - percentage: 99 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 1 + "True": 99 test-flag7000: - percentage: 0 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 100 + "True": 0 test-flag7001: - percentage: 1 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 99 + "True": 1 test-flag7002: - percentage: 2 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 98 + "True": 2 test-flag7003: - percentage: 3 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 97 + "True": 3 test-flag7004: - percentage: 4 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 96 + "True": 4 test-flag7005: - percentage: 5 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 95 + "True": 5 test-flag7006: - percentage: 6 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 94 + "True": 6 test-flag7007: - percentage: 7 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 93 + "True": 7 test-flag7008: - percentage: 8 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 92 + "True": 8 test-flag7009: - percentage: 9 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 91 + "True": 9 test-flag7010: - percentage: 10 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 90 + "True": 10 test-flag7011: - percentage: 11 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 89 + "True": 11 test-flag7012: - percentage: 12 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 88 + "True": 12 test-flag7013: - percentage: 13 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 87 + "True": 13 test-flag7014: - percentage: 14 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 86 + "True": 14 test-flag7015: - percentage: 15 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 85 + "True": 15 test-flag7016: - percentage: 16 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 84 + "True": 16 test-flag7017: - percentage: 17 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 83 + "True": 17 test-flag7018: - percentage: 18 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 82 + "True": 18 test-flag7019: - percentage: 19 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 81 + "True": 19 test-flag7020: - percentage: 20 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 80 + "True": 20 test-flag7021: - percentage: 21 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 79 + "True": 21 test-flag7022: - percentage: 22 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 78 + "True": 22 test-flag7023: - percentage: 23 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 77 + "True": 23 test-flag7024: - percentage: 24 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 76 + "True": 24 test-flag7025: - percentage: 25 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 75 + "True": 25 test-flag7026: - percentage: 26 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 74 + "True": 26 test-flag7027: - percentage: 27 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 73 + "True": 27 test-flag7028: - percentage: 28 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 72 + "True": 28 test-flag7029: - percentage: 29 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 71 + "True": 29 test-flag7030: - percentage: 30 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 70 + "True": 30 test-flag7031: - percentage: 31 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 69 + "True": 31 test-flag7032: - percentage: 32 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 68 + "True": 32 test-flag7033: - percentage: 33 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 67 + "True": 33 test-flag7034: - percentage: 34 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 66 + "True": 34 test-flag7035: - percentage: 35 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 65 + "True": 35 test-flag7036: - percentage: 36 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 64 + "True": 36 test-flag7037: - percentage: 37 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 63 + "True": 37 test-flag7038: - percentage: 38 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 62 + "True": 38 test-flag7039: - percentage: 39 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 61 + "True": 39 test-flag7040: - percentage: 40 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 60 + "True": 40 test-flag7041: - percentage: 41 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 59 + "True": 41 test-flag7042: - percentage: 42 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 58 + "True": 42 test-flag7043: - percentage: 43 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 57 + "True": 43 test-flag7044: - percentage: 44 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 56 + "True": 44 test-flag7045: - percentage: 45 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 55 + "True": 45 test-flag7046: - percentage: 46 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 54 + "True": 46 test-flag7047: - percentage: 47 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 53 + "True": 47 test-flag7048: - percentage: 48 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 52 + "True": 48 test-flag7049: - percentage: 49 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 51 + "True": 49 test-flag7050: - percentage: 50 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 50 + "True": 50 test-flag7051: - percentage: 51 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 49 + "True": 51 test-flag7052: - percentage: 52 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 48 + "True": 52 test-flag7053: - percentage: 53 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 47 + "True": 53 test-flag7054: - percentage: 54 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 46 + "True": 54 test-flag7055: - percentage: 55 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 45 + "True": 55 test-flag7056: - percentage: 56 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 44 + "True": 56 test-flag7057: - percentage: 57 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 43 + "True": 57 test-flag7058: - percentage: 58 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 42 + "True": 58 test-flag7059: - percentage: 59 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 41 + "True": 59 test-flag7060: - percentage: 60 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 40 + "True": 60 test-flag7061: - percentage: 61 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 39 + "True": 61 test-flag7062: - percentage: 62 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 38 + "True": 62 test-flag7063: - percentage: 63 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 37 + "True": 63 test-flag7064: - percentage: 64 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 36 + "True": 64 test-flag7065: - percentage: 65 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 35 + "True": 65 test-flag7066: - percentage: 66 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 34 + "True": 66 test-flag7067: - percentage: 67 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 33 + "True": 67 test-flag7068: - percentage: 68 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 32 + "True": 68 test-flag7069: - percentage: 69 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 31 + "True": 69 test-flag7070: - percentage: 70 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 30 + "True": 70 test-flag7071: - percentage: 71 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 29 + "True": 71 test-flag7072: - percentage: 72 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 28 + "True": 72 test-flag7073: - percentage: 73 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 27 + "True": 73 test-flag7074: - percentage: 74 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 26 + "True": 74 test-flag7075: - percentage: 75 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 25 + "True": 75 test-flag7076: - percentage: 76 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 24 + "True": 76 test-flag7077: - percentage: 77 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 23 + "True": 77 test-flag7078: - percentage: 78 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 22 + "True": 78 test-flag7079: - percentage: 79 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 21 + "True": 79 test-flag7080: - percentage: 80 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 20 + "True": 80 test-flag7081: - percentage: 81 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 19 + "True": 81 test-flag7082: - percentage: 82 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 18 + "True": 82 test-flag7083: - percentage: 83 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 17 + "True": 83 test-flag7084: - percentage: 84 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 16 + "True": 84 test-flag7085: - percentage: 85 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 15 + "True": 85 test-flag7086: - percentage: 86 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 14 + "True": 86 test-flag7087: - percentage: 87 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 13 + "True": 87 test-flag7088: - percentage: 88 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 12 + "True": 88 test-flag7089: - percentage: 89 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 11 + "True": 89 test-flag7090: - percentage: 90 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 10 + "True": 90 test-flag7091: - percentage: 91 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 9 + "True": 91 test-flag7092: - percentage: 92 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 8 + "True": 92 test-flag7093: - percentage: 93 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 7 + "True": 93 test-flag7094: - percentage: 94 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 6 + "True": 94 test-flag7095: - percentage: 95 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 5 + "True": 95 test-flag7096: - percentage: 96 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 4 + "True": 96 test-flag7097: - percentage: 97 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 3 + "True": 97 test-flag7098: - percentage: 98 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 2 + "True": 98 test-flag7099: - percentage: 99 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 1 + "True": 99 test-flag7100: - percentage: 0 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 100 + "True": 0 test-flag7101: - percentage: 1 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 99 + "True": 1 test-flag7102: - percentage: 2 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 98 + "True": 2 test-flag7103: - percentage: 3 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 97 + "True": 3 test-flag7104: - percentage: 4 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 96 + "True": 4 test-flag7105: - percentage: 5 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 95 + "True": 5 test-flag7106: - percentage: 6 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 94 + "True": 6 test-flag7107: - percentage: 7 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 93 + "True": 7 test-flag7108: - percentage: 8 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 92 + "True": 8 test-flag7109: - percentage: 9 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 91 + "True": 9 test-flag7110: - percentage: 10 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 90 + "True": 10 test-flag7111: - percentage: 11 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 89 + "True": 11 test-flag7112: - percentage: 12 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 88 + "True": 12 test-flag7113: - percentage: 13 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 87 + "True": 13 test-flag7114: - percentage: 14 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 86 + "True": 14 test-flag7115: - percentage: 15 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 85 + "True": 15 test-flag7116: - percentage: 16 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 84 + "True": 16 test-flag7117: - percentage: 17 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 83 + "True": 17 test-flag7118: - percentage: 18 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 82 + "True": 18 test-flag7119: - percentage: 19 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 81 + "True": 19 test-flag7120: - percentage: 20 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 80 + "True": 20 test-flag7121: - percentage: 21 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 79 + "True": 21 test-flag7122: - percentage: 22 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 78 + "True": 22 test-flag7123: - percentage: 23 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 77 + "True": 23 test-flag7124: - percentage: 24 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 76 + "True": 24 test-flag7125: - percentage: 25 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 75 + "True": 25 test-flag7126: - percentage: 26 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 74 + "True": 26 test-flag7127: - percentage: 27 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 73 + "True": 27 test-flag7128: - percentage: 28 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 72 + "True": 28 test-flag7129: - percentage: 29 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 71 + "True": 29 test-flag7130: - percentage: 30 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 70 + "True": 30 test-flag7131: - percentage: 31 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 69 + "True": 31 test-flag7132: - percentage: 32 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 68 + "True": 32 test-flag7133: - percentage: 33 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 67 + "True": 33 test-flag7134: - percentage: 34 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 66 + "True": 34 test-flag7135: - percentage: 35 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 65 + "True": 35 test-flag7136: - percentage: 36 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 64 + "True": 36 test-flag7137: - percentage: 37 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 63 + "True": 37 test-flag7138: - percentage: 38 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 62 + "True": 38 test-flag7139: - percentage: 39 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 61 + "True": 39 test-flag7140: - percentage: 40 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 60 + "True": 40 test-flag7141: - percentage: 41 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 59 + "True": 41 test-flag7142: - percentage: 42 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 58 + "True": 42 test-flag7143: - percentage: 43 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 57 + "True": 43 test-flag7144: - percentage: 44 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 56 + "True": 44 test-flag7145: - percentage: 45 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 55 + "True": 45 test-flag7146: - percentage: 46 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 54 + "True": 46 test-flag7147: - percentage: 47 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 53 + "True": 47 test-flag7148: - percentage: 48 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 52 + "True": 48 test-flag7149: - percentage: 49 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 51 + "True": 49 test-flag7150: - percentage: 50 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 50 + "True": 50 test-flag7151: - percentage: 51 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 49 + "True": 51 test-flag7152: - percentage: 52 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 48 + "True": 52 test-flag7153: - percentage: 53 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 47 + "True": 53 test-flag7154: - percentage: 54 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 46 + "True": 54 test-flag7155: - percentage: 55 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 45 + "True": 55 test-flag7156: - percentage: 56 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 44 + "True": 56 test-flag7157: - percentage: 57 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 43 + "True": 57 test-flag7158: - percentage: 58 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 42 + "True": 58 test-flag7159: - percentage: 59 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 41 + "True": 59 test-flag7160: - percentage: 60 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 40 + "True": 60 test-flag7161: - percentage: 61 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 39 + "True": 61 test-flag7162: - percentage: 62 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 38 + "True": 62 test-flag7163: - percentage: 63 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 37 + "True": 63 test-flag7164: - percentage: 64 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 36 + "True": 64 test-flag7165: - percentage: 65 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 35 + "True": 65 test-flag7166: - percentage: 66 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 34 + "True": 66 test-flag7167: - percentage: 67 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 33 + "True": 67 test-flag7168: - percentage: 68 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 32 + "True": 68 test-flag7169: - percentage: 69 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 31 + "True": 69 test-flag7170: - percentage: 70 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 30 + "True": 70 test-flag7171: - percentage: 71 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 29 + "True": 71 test-flag7172: - percentage: 72 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 28 + "True": 72 test-flag7173: - percentage: 73 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 27 + "True": 73 test-flag7174: - percentage: 74 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 26 + "True": 74 test-flag7175: - percentage: 75 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 25 + "True": 75 test-flag7176: - percentage: 76 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 24 + "True": 76 test-flag7177: - percentage: 77 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 23 + "True": 77 test-flag7178: - percentage: 78 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 22 + "True": 78 test-flag7179: - percentage: 79 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 21 + "True": 79 test-flag7180: - percentage: 80 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 20 + "True": 80 test-flag7181: - percentage: 81 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 19 + "True": 81 test-flag7182: - percentage: 82 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 18 + "True": 82 test-flag7183: - percentage: 83 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 17 + "True": 83 test-flag7184: - percentage: 84 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 16 + "True": 84 test-flag7185: - percentage: 85 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 15 + "True": 85 test-flag7186: - percentage: 86 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 14 + "True": 86 test-flag7187: - percentage: 87 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 13 + "True": 87 test-flag7188: - percentage: 88 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 12 + "True": 88 test-flag7189: - percentage: 89 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 11 + "True": 89 test-flag7190: - percentage: 90 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 10 + "True": 90 test-flag7191: - percentage: 91 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 9 + "True": 91 test-flag7192: - percentage: 92 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 8 + "True": 92 test-flag7193: - percentage: 93 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 7 + "True": 93 test-flag7194: - percentage: 94 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 6 + "True": 94 test-flag7195: - percentage: 95 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 5 + "True": 95 test-flag7196: - percentage: 96 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 4 + "True": 96 test-flag7197: - percentage: 97 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 3 + "True": 97 test-flag7198: - percentage: 98 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 2 + "True": 98 test-flag7199: - percentage: 99 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 1 + "True": 99 test-flag7200: - percentage: 0 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 100 + "True": 0 test-flag7201: - percentage: 1 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 99 + "True": 1 test-flag7202: - percentage: 2 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 98 + "True": 2 test-flag7203: - percentage: 3 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 97 + "True": 3 test-flag7204: - percentage: 4 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 96 + "True": 4 test-flag7205: - percentage: 5 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 95 + "True": 5 test-flag7206: - percentage: 6 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 94 + "True": 6 test-flag7207: - percentage: 7 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 93 + "True": 7 test-flag7208: - percentage: 8 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 92 + "True": 8 test-flag7209: - percentage: 9 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 91 + "True": 9 test-flag7210: - percentage: 10 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 90 + "True": 10 test-flag7211: - percentage: 11 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 89 + "True": 11 test-flag7212: - percentage: 12 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 88 + "True": 12 test-flag7213: - percentage: 13 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 87 + "True": 13 test-flag7214: - percentage: 14 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 86 + "True": 14 test-flag7215: - percentage: 15 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 85 + "True": 15 test-flag7216: - percentage: 16 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 84 + "True": 16 test-flag7217: - percentage: 17 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 83 + "True": 17 test-flag7218: - percentage: 18 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 82 + "True": 18 test-flag7219: - percentage: 19 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 81 + "True": 19 test-flag7220: - percentage: 20 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 80 + "True": 20 test-flag7221: - percentage: 21 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 79 + "True": 21 test-flag7222: - percentage: 22 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 78 + "True": 22 test-flag7223: - percentage: 23 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 77 + "True": 23 test-flag7224: - percentage: 24 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 76 + "True": 24 test-flag7225: - percentage: 25 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 75 + "True": 25 test-flag7226: - percentage: 26 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 74 + "True": 26 test-flag7227: - percentage: 27 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 73 + "True": 27 test-flag7228: - percentage: 28 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 72 + "True": 28 test-flag7229: - percentage: 29 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 71 + "True": 29 test-flag7230: - percentage: 30 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 70 + "True": 30 test-flag7231: - percentage: 31 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 69 + "True": 31 test-flag7232: - percentage: 32 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 68 + "True": 32 test-flag7233: - percentage: 33 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 67 + "True": 33 test-flag7234: - percentage: 34 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 66 + "True": 34 test-flag7235: - percentage: 35 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 65 + "True": 35 test-flag7236: - percentage: 36 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 64 + "True": 36 test-flag7237: - percentage: 37 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 63 + "True": 37 test-flag7238: - percentage: 38 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 62 + "True": 38 test-flag7239: - percentage: 39 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 61 + "True": 39 test-flag7240: - percentage: 40 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 60 + "True": 40 test-flag7241: - percentage: 41 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 59 + "True": 41 test-flag7242: - percentage: 42 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 58 + "True": 42 test-flag7243: - percentage: 43 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 57 + "True": 43 test-flag7244: - percentage: 44 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 56 + "True": 44 test-flag7245: - percentage: 45 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 55 + "True": 45 test-flag7246: - percentage: 46 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 54 + "True": 46 test-flag7247: - percentage: 47 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 53 + "True": 47 test-flag7248: - percentage: 48 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 52 + "True": 48 test-flag7249: - percentage: 49 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 51 + "True": 49 test-flag7250: - percentage: 50 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 50 + "True": 50 test-flag7251: - percentage: 51 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 49 + "True": 51 test-flag7252: - percentage: 52 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 48 + "True": 52 test-flag7253: - percentage: 53 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 47 + "True": 53 test-flag7254: - percentage: 54 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 46 + "True": 54 test-flag7255: - percentage: 55 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 45 + "True": 55 test-flag7256: - percentage: 56 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 44 + "True": 56 test-flag7257: - percentage: 57 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 43 + "True": 57 test-flag7258: - percentage: 58 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 42 + "True": 58 test-flag7259: - percentage: 59 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 41 + "True": 59 test-flag7260: - percentage: 60 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 40 + "True": 60 test-flag7261: - percentage: 61 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 39 + "True": 61 test-flag7262: - percentage: 62 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 38 + "True": 62 test-flag7263: - percentage: 63 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 37 + "True": 63 test-flag7264: - percentage: 64 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 36 + "True": 64 test-flag7265: - percentage: 65 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 35 + "True": 65 test-flag7266: - percentage: 66 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 34 + "True": 66 test-flag7267: - percentage: 67 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 33 + "True": 67 test-flag7268: - percentage: 68 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 32 + "True": 68 test-flag7269: - percentage: 69 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 31 + "True": 69 test-flag7270: - percentage: 70 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 30 + "True": 70 test-flag7271: - percentage: 71 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 29 + "True": 71 test-flag7272: - percentage: 72 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 28 + "True": 72 test-flag7273: - percentage: 73 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 27 + "True": 73 test-flag7274: - percentage: 74 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 26 + "True": 74 test-flag7275: - percentage: 75 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 25 + "True": 75 test-flag7276: - percentage: 76 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 24 + "True": 76 test-flag7277: - percentage: 77 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 23 + "True": 77 test-flag7278: - percentage: 78 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 22 + "True": 78 test-flag7279: - percentage: 79 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 21 + "True": 79 test-flag7280: - percentage: 80 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 20 + "True": 80 test-flag7281: - percentage: 81 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 19 + "True": 81 test-flag7282: - percentage: 82 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 18 + "True": 82 test-flag7283: - percentage: 83 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 17 + "True": 83 test-flag7284: - percentage: 84 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 16 + "True": 84 test-flag7285: - percentage: 85 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 15 + "True": 85 test-flag7286: - percentage: 86 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 14 + "True": 86 test-flag7287: - percentage: 87 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 13 + "True": 87 test-flag7288: - percentage: 88 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 12 + "True": 88 test-flag7289: - percentage: 89 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 11 + "True": 89 test-flag7290: - percentage: 90 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 10 + "True": 90 test-flag7291: - percentage: 91 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 9 + "True": 91 test-flag7292: - percentage: 92 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 8 + "True": 92 test-flag7293: - percentage: 93 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 7 + "True": 93 test-flag7294: - percentage: 94 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 6 + "True": 94 test-flag7295: - percentage: 95 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 5 + "True": 95 test-flag7296: - percentage: 96 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 4 + "True": 96 test-flag7297: - percentage: 97 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 3 + "True": 97 test-flag7298: - percentage: 98 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 2 + "True": 98 test-flag7299: - percentage: 99 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 1 + "True": 99 test-flag7300: - percentage: 0 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 100 + "True": 0 test-flag7301: - percentage: 1 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 99 + "True": 1 test-flag7302: - percentage: 2 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 98 + "True": 2 test-flag7303: - percentage: 3 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 97 + "True": 3 test-flag7304: - percentage: 4 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 96 + "True": 4 test-flag7305: - percentage: 5 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 95 + "True": 5 test-flag7306: - percentage: 6 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 94 + "True": 6 test-flag7307: - percentage: 7 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 93 + "True": 7 test-flag7308: - percentage: 8 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 92 + "True": 8 test-flag7309: - percentage: 9 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 91 + "True": 9 test-flag7310: - percentage: 10 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 90 + "True": 10 test-flag7311: - percentage: 11 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 89 + "True": 11 test-flag7312: - percentage: 12 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 88 + "True": 12 test-flag7313: - percentage: 13 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 87 + "True": 13 test-flag7314: - percentage: 14 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 86 + "True": 14 test-flag7315: - percentage: 15 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 85 + "True": 15 test-flag7316: - percentage: 16 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 84 + "True": 16 test-flag7317: - percentage: 17 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 83 + "True": 17 test-flag7318: - percentage: 18 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 82 + "True": 18 test-flag7319: - percentage: 19 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 81 + "True": 19 test-flag7320: - percentage: 20 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 80 + "True": 20 test-flag7321: - percentage: 21 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 79 + "True": 21 test-flag7322: - percentage: 22 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 78 + "True": 22 test-flag7323: - percentage: 23 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 77 + "True": 23 test-flag7324: - percentage: 24 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 76 + "True": 24 test-flag7325: - percentage: 25 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 75 + "True": 25 test-flag7326: - percentage: 26 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 74 + "True": 26 test-flag7327: - percentage: 27 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 73 + "True": 27 test-flag7328: - percentage: 28 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 72 + "True": 28 test-flag7329: - percentage: 29 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 71 + "True": 29 test-flag7330: - percentage: 30 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 70 + "True": 30 test-flag7331: - percentage: 31 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 69 + "True": 31 test-flag7332: - percentage: 32 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 68 + "True": 32 test-flag7333: - percentage: 33 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 67 + "True": 33 test-flag7334: - percentage: 34 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 66 + "True": 34 test-flag7335: - percentage: 35 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 65 + "True": 35 test-flag7336: - percentage: 36 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 64 + "True": 36 test-flag7337: - percentage: 37 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 63 + "True": 37 test-flag7338: - percentage: 38 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 62 + "True": 38 test-flag7339: - percentage: 39 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 61 + "True": 39 test-flag7340: - percentage: 40 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 60 + "True": 40 test-flag7341: - percentage: 41 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 59 + "True": 41 test-flag7342: - percentage: 42 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 58 + "True": 42 test-flag7343: - percentage: 43 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 57 + "True": 43 test-flag7344: - percentage: 44 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 56 + "True": 44 test-flag7345: - percentage: 45 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 55 + "True": 45 test-flag7346: - percentage: 46 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 54 + "True": 46 test-flag7347: - percentage: 47 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 53 + "True": 47 test-flag7348: - percentage: 48 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 52 + "True": 48 test-flag7349: - percentage: 49 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 51 + "True": 49 test-flag7350: - percentage: 50 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 50 + "True": 50 test-flag7351: - percentage: 51 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 49 + "True": 51 test-flag7352: - percentage: 52 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 48 + "True": 52 test-flag7353: - percentage: 53 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 47 + "True": 53 test-flag7354: - percentage: 54 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 46 + "True": 54 test-flag7355: - percentage: 55 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 45 + "True": 55 test-flag7356: - percentage: 56 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 44 + "True": 56 test-flag7357: - percentage: 57 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 43 + "True": 57 test-flag7358: - percentage: 58 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 42 + "True": 58 test-flag7359: - percentage: 59 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 41 + "True": 59 test-flag7360: - percentage: 60 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 40 + "True": 60 test-flag7361: - percentage: 61 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 39 + "True": 61 test-flag7362: - percentage: 62 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 38 + "True": 62 test-flag7363: - percentage: 63 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 37 + "True": 63 test-flag7364: - percentage: 64 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 36 + "True": 64 test-flag7365: - percentage: 65 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 35 + "True": 65 test-flag7366: - percentage: 66 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 34 + "True": 66 test-flag7367: - percentage: 67 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 33 + "True": 67 test-flag7368: - percentage: 68 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 32 + "True": 68 test-flag7369: - percentage: 69 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 31 + "True": 69 test-flag7370: - percentage: 70 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 30 + "True": 70 test-flag7371: - percentage: 71 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 29 + "True": 71 test-flag7372: - percentage: 72 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 28 + "True": 72 test-flag7373: - percentage: 73 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 27 + "True": 73 test-flag7374: - percentage: 74 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 26 + "True": 74 test-flag7375: - percentage: 75 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 25 + "True": 75 test-flag7376: - percentage: 76 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 24 + "True": 76 test-flag7377: - percentage: 77 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 23 + "True": 77 test-flag7378: - percentage: 78 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 22 + "True": 78 test-flag7379: - percentage: 79 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 21 + "True": 79 test-flag7380: - percentage: 80 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 20 + "True": 80 test-flag7381: - percentage: 81 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 19 + "True": 81 test-flag7382: - percentage: 82 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 18 + "True": 82 test-flag7383: - percentage: 83 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 17 + "True": 83 test-flag7384: - percentage: 84 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 16 + "True": 84 test-flag7385: - percentage: 85 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 15 + "True": 85 test-flag7386: - percentage: 86 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 14 + "True": 86 test-flag7387: - percentage: 87 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 13 + "True": 87 test-flag7388: - percentage: 88 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 12 + "True": 88 test-flag7389: - percentage: 89 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 11 + "True": 89 test-flag7390: - percentage: 90 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 10 + "True": 90 test-flag7391: - percentage: 91 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 9 + "True": 91 test-flag7392: - percentage: 92 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 8 + "True": 92 test-flag7393: - percentage: 93 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 7 + "True": 93 test-flag7394: - percentage: 94 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 6 + "True": 94 test-flag7395: - percentage: 95 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 5 + "True": 95 test-flag7396: - percentage: 96 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 4 + "True": 96 test-flag7397: - percentage: 97 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 3 + "True": 97 test-flag7398: - percentage: 98 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 2 + "True": 98 test-flag7399: - percentage: 99 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 1 + "True": 99 test-flag7400: - percentage: 0 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 100 + "True": 0 test-flag7401: - percentage: 1 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 99 + "True": 1 test-flag7402: - percentage: 2 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 98 + "True": 2 test-flag7403: - percentage: 3 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 97 + "True": 3 test-flag7404: - percentage: 4 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 96 + "True": 4 test-flag7405: - percentage: 5 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 95 + "True": 5 test-flag7406: - percentage: 6 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 94 + "True": 6 test-flag7407: - percentage: 7 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 93 + "True": 7 test-flag7408: - percentage: 8 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 92 + "True": 8 test-flag7409: - percentage: 9 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 91 + "True": 9 test-flag7410: - percentage: 10 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 90 + "True": 10 test-flag7411: - percentage: 11 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 89 + "True": 11 test-flag7412: - percentage: 12 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 88 + "True": 12 test-flag7413: - percentage: 13 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 87 + "True": 13 test-flag7414: - percentage: 14 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 86 + "True": 14 test-flag7415: - percentage: 15 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 85 + "True": 15 test-flag7416: - percentage: 16 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 84 + "True": 16 test-flag7417: - percentage: 17 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 83 + "True": 17 test-flag7418: - percentage: 18 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 82 + "True": 18 test-flag7419: - percentage: 19 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 81 + "True": 19 test-flag7420: - percentage: 20 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 80 + "True": 20 test-flag7421: - percentage: 21 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 79 + "True": 21 test-flag7422: - percentage: 22 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 78 + "True": 22 test-flag7423: - percentage: 23 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 77 + "True": 23 test-flag7424: - percentage: 24 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 76 + "True": 24 test-flag7425: - percentage: 25 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 75 + "True": 25 test-flag7426: - percentage: 26 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 74 + "True": 26 test-flag7427: - percentage: 27 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 73 + "True": 27 test-flag7428: - percentage: 28 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 72 + "True": 28 test-flag7429: - percentage: 29 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 71 + "True": 29 test-flag7430: - percentage: 30 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 70 + "True": 30 test-flag7431: - percentage: 31 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 69 + "True": 31 test-flag7432: - percentage: 32 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 68 + "True": 32 test-flag7433: - percentage: 33 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 67 + "True": 33 test-flag7434: - percentage: 34 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 66 + "True": 34 test-flag7435: - percentage: 35 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 65 + "True": 35 test-flag7436: - percentage: 36 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 64 + "True": 36 test-flag7437: - percentage: 37 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 63 + "True": 37 test-flag7438: - percentage: 38 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 62 + "True": 38 test-flag7439: - percentage: 39 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 61 + "True": 39 test-flag7440: - percentage: 40 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 60 + "True": 40 test-flag7441: - percentage: 41 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 59 + "True": 41 test-flag7442: - percentage: 42 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 58 + "True": 42 test-flag7443: - percentage: 43 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 57 + "True": 43 test-flag7444: - percentage: 44 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 56 + "True": 44 test-flag7445: - percentage: 45 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 55 + "True": 45 test-flag7446: - percentage: 46 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 54 + "True": 46 test-flag7447: - percentage: 47 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 53 + "True": 47 test-flag7448: - percentage: 48 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 52 + "True": 48 test-flag7449: - percentage: 49 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 51 + "True": 49 test-flag7450: - percentage: 50 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 50 + "True": 50 test-flag7451: - percentage: 51 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 49 + "True": 51 test-flag7452: - percentage: 52 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 48 + "True": 52 test-flag7453: - percentage: 53 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 47 + "True": 53 test-flag7454: - percentage: 54 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 46 + "True": 54 test-flag7455: - percentage: 55 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 45 + "True": 55 test-flag7456: - percentage: 56 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 44 + "True": 56 test-flag7457: - percentage: 57 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 43 + "True": 57 test-flag7458: - percentage: 58 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 42 + "True": 58 test-flag7459: - percentage: 59 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 41 + "True": 59 test-flag7460: - percentage: 60 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 40 + "True": 60 test-flag7461: - percentage: 61 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 39 + "True": 61 test-flag7462: - percentage: 62 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 38 + "True": 62 test-flag7463: - percentage: 63 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 37 + "True": 63 test-flag7464: - percentage: 64 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 36 + "True": 64 test-flag7465: - percentage: 65 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 35 + "True": 65 test-flag7466: - percentage: 66 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 34 + "True": 66 test-flag7467: - percentage: 67 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 33 + "True": 67 test-flag7468: - percentage: 68 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 32 + "True": 68 test-flag7469: - percentage: 69 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 31 + "True": 69 test-flag7470: - percentage: 70 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 30 + "True": 70 test-flag7471: - percentage: 71 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 29 + "True": 71 test-flag7472: - percentage: 72 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 28 + "True": 72 test-flag7473: - percentage: 73 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 27 + "True": 73 test-flag7474: - percentage: 74 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 26 + "True": 74 test-flag7475: - percentage: 75 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 25 + "True": 75 test-flag7476: - percentage: 76 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 24 + "True": 76 test-flag7477: - percentage: 77 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 23 + "True": 77 test-flag7478: - percentage: 78 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 22 + "True": 78 test-flag7479: - percentage: 79 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 21 + "True": 79 test-flag7480: - percentage: 80 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 20 + "True": 80 test-flag7481: - percentage: 81 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 19 + "True": 81 test-flag7482: - percentage: 82 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 18 + "True": 82 test-flag7483: - percentage: 83 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 17 + "True": 83 test-flag7484: - percentage: 84 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 16 + "True": 84 test-flag7485: - percentage: 85 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 15 + "True": 85 test-flag7486: - percentage: 86 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 14 + "True": 86 test-flag7487: - percentage: 87 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 13 + "True": 87 test-flag7488: - percentage: 88 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 12 + "True": 88 test-flag7489: - percentage: 89 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 11 + "True": 89 test-flag7490: - percentage: 90 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 10 + "True": 90 test-flag7491: - percentage: 91 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 9 + "True": 91 test-flag7492: - percentage: 92 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 8 + "True": 92 test-flag7493: - percentage: 93 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 7 + "True": 93 test-flag7494: - percentage: 94 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 6 + "True": 94 test-flag7495: - percentage: 95 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 5 + "True": 95 test-flag7496: - percentage: 96 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 4 + "True": 96 test-flag7497: - percentage: 97 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 3 + "True": 97 test-flag7498: - percentage: 98 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 2 + "True": 98 test-flag7499: - percentage: 99 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 1 + "True": 99 test-flag7500: - percentage: 0 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 100 + "True": 0 test-flag7501: - percentage: 1 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 99 + "True": 1 test-flag7502: - percentage: 2 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 98 + "True": 2 test-flag7503: - percentage: 3 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 97 + "True": 3 test-flag7504: - percentage: 4 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 96 + "True": 4 test-flag7505: - percentage: 5 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 95 + "True": 5 test-flag7506: - percentage: 6 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 94 + "True": 6 test-flag7507: - percentage: 7 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 93 + "True": 7 test-flag7508: - percentage: 8 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 92 + "True": 8 test-flag7509: - percentage: 9 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 91 + "True": 9 test-flag7510: - percentage: 10 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 90 + "True": 10 test-flag7511: - percentage: 11 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 89 + "True": 11 test-flag7512: - percentage: 12 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 88 + "True": 12 test-flag7513: - percentage: 13 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 87 + "True": 13 test-flag7514: - percentage: 14 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 86 + "True": 14 test-flag7515: - percentage: 15 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 85 + "True": 15 test-flag7516: - percentage: 16 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 84 + "True": 16 test-flag7517: - percentage: 17 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 83 + "True": 17 test-flag7518: - percentage: 18 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 82 + "True": 18 test-flag7519: - percentage: 19 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 81 + "True": 19 test-flag7520: - percentage: 20 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 80 + "True": 20 test-flag7521: - percentage: 21 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 79 + "True": 21 test-flag7522: - percentage: 22 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 78 + "True": 22 test-flag7523: - percentage: 23 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 77 + "True": 23 test-flag7524: - percentage: 24 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 76 + "True": 24 test-flag7525: - percentage: 25 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 75 + "True": 25 test-flag7526: - percentage: 26 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 74 + "True": 26 test-flag7527: - percentage: 27 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 73 + "True": 27 test-flag7528: - percentage: 28 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 72 + "True": 28 test-flag7529: - percentage: 29 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 71 + "True": 29 test-flag7530: - percentage: 30 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 70 + "True": 30 test-flag7531: - percentage: 31 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 69 + "True": 31 test-flag7532: - percentage: 32 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 68 + "True": 32 test-flag7533: - percentage: 33 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 67 + "True": 33 test-flag7534: - percentage: 34 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 66 + "True": 34 test-flag7535: - percentage: 35 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 65 + "True": 35 test-flag7536: - percentage: 36 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 64 + "True": 36 test-flag7537: - percentage: 37 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 63 + "True": 37 test-flag7538: - percentage: 38 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 62 + "True": 38 test-flag7539: - percentage: 39 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 61 + "True": 39 test-flag7540: - percentage: 40 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 60 + "True": 40 test-flag7541: - percentage: 41 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 59 + "True": 41 test-flag7542: - percentage: 42 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 58 + "True": 42 test-flag7543: - percentage: 43 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 57 + "True": 43 test-flag7544: - percentage: 44 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 56 + "True": 44 test-flag7545: - percentage: 45 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 55 + "True": 45 test-flag7546: - percentage: 46 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 54 + "True": 46 test-flag7547: - percentage: 47 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 53 + "True": 47 test-flag7548: - percentage: 48 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 52 + "True": 48 test-flag7549: - percentage: 49 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 51 + "True": 49 test-flag7550: - percentage: 50 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 50 + "True": 50 test-flag7551: - percentage: 51 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 49 + "True": 51 test-flag7552: - percentage: 52 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 48 + "True": 52 test-flag7553: - percentage: 53 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 47 + "True": 53 test-flag7554: - percentage: 54 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 46 + "True": 54 test-flag7555: - percentage: 55 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 45 + "True": 55 test-flag7556: - percentage: 56 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 44 + "True": 56 test-flag7557: - percentage: 57 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 43 + "True": 57 test-flag7558: - percentage: 58 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 42 + "True": 58 test-flag7559: - percentage: 59 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 41 + "True": 59 test-flag7560: - percentage: 60 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 40 + "True": 60 test-flag7561: - percentage: 61 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 39 + "True": 61 test-flag7562: - percentage: 62 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 38 + "True": 62 test-flag7563: - percentage: 63 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 37 + "True": 63 test-flag7564: - percentage: 64 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 36 + "True": 64 test-flag7565: - percentage: 65 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 35 + "True": 65 test-flag7566: - percentage: 66 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 34 + "True": 66 test-flag7567: - percentage: 67 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 33 + "True": 67 test-flag7568: - percentage: 68 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 32 + "True": 68 test-flag7569: - percentage: 69 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 31 + "True": 69 test-flag7570: - percentage: 70 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 30 + "True": 70 test-flag7571: - percentage: 71 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 29 + "True": 71 test-flag7572: - percentage: 72 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 28 + "True": 72 test-flag7573: - percentage: 73 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 27 + "True": 73 test-flag7574: - percentage: 74 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 26 + "True": 74 test-flag7575: - percentage: 75 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 25 + "True": 75 test-flag7576: - percentage: 76 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 24 + "True": 76 test-flag7577: - percentage: 77 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 23 + "True": 77 test-flag7578: - percentage: 78 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 22 + "True": 78 test-flag7579: - percentage: 79 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 21 + "True": 79 test-flag7580: - percentage: 80 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 20 + "True": 80 test-flag7581: - percentage: 81 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 19 + "True": 81 test-flag7582: - percentage: 82 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 18 + "True": 82 test-flag7583: - percentage: 83 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 17 + "True": 83 test-flag7584: - percentage: 84 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 16 + "True": 84 test-flag7585: - percentage: 85 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 15 + "True": 85 test-flag7586: - percentage: 86 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 14 + "True": 86 test-flag7587: - percentage: 87 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 13 + "True": 87 test-flag7588: - percentage: 88 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 12 + "True": 88 test-flag7589: - percentage: 89 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 11 + "True": 89 test-flag7590: - percentage: 90 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 10 + "True": 90 test-flag7591: - percentage: 91 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 9 + "True": 91 test-flag7592: - percentage: 92 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 8 + "True": 92 test-flag7593: - percentage: 93 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 7 + "True": 93 test-flag7594: - percentage: 94 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 6 + "True": 94 test-flag7595: - percentage: 95 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 5 + "True": 95 test-flag7596: - percentage: 96 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 4 + "True": 96 test-flag7597: - percentage: 97 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 3 + "True": 97 test-flag7598: - percentage: 98 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 2 + "True": 98 test-flag7599: - percentage: 99 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 1 + "True": 99 test-flag7600: - percentage: 0 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 100 + "True": 0 test-flag7601: - percentage: 1 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 99 + "True": 1 test-flag7602: - percentage: 2 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 98 + "True": 2 test-flag7603: - percentage: 3 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 97 + "True": 3 test-flag7604: - percentage: 4 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 96 + "True": 4 test-flag7605: - percentage: 5 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 95 + "True": 5 test-flag7606: - percentage: 6 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 94 + "True": 6 test-flag7607: - percentage: 7 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 93 + "True": 7 test-flag7608: - percentage: 8 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 92 + "True": 8 test-flag7609: - percentage: 9 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 91 + "True": 9 test-flag7610: - percentage: 10 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 90 + "True": 10 test-flag7611: - percentage: 11 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 89 + "True": 11 test-flag7612: - percentage: 12 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 88 + "True": 12 test-flag7613: - percentage: 13 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 87 + "True": 13 test-flag7614: - percentage: 14 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 86 + "True": 14 test-flag7615: - percentage: 15 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 85 + "True": 15 test-flag7616: - percentage: 16 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 84 + "True": 16 test-flag7617: - percentage: 17 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 83 + "True": 17 test-flag7618: - percentage: 18 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 82 + "True": 18 test-flag7619: - percentage: 19 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 81 + "True": 19 test-flag7620: - percentage: 20 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 80 + "True": 20 test-flag7621: - percentage: 21 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 79 + "True": 21 test-flag7622: - percentage: 22 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 78 + "True": 22 test-flag7623: - percentage: 23 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 77 + "True": 23 test-flag7624: - percentage: 24 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 76 + "True": 24 test-flag7625: - percentage: 25 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 75 + "True": 25 test-flag7626: - percentage: 26 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 74 + "True": 26 test-flag7627: - percentage: 27 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 73 + "True": 27 test-flag7628: - percentage: 28 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 72 + "True": 28 test-flag7629: - percentage: 29 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 71 + "True": 29 test-flag7630: - percentage: 30 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 70 + "True": 30 test-flag7631: - percentage: 31 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 69 + "True": 31 test-flag7632: - percentage: 32 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 68 + "True": 32 test-flag7633: - percentage: 33 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 67 + "True": 33 test-flag7634: - percentage: 34 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 66 + "True": 34 test-flag7635: - percentage: 35 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 65 + "True": 35 test-flag7636: - percentage: 36 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 64 + "True": 36 test-flag7637: - percentage: 37 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 63 + "True": 37 test-flag7638: - percentage: 38 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 62 + "True": 38 test-flag7639: - percentage: 39 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 61 + "True": 39 test-flag7640: - percentage: 40 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 60 + "True": 40 test-flag7641: - percentage: 41 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 59 + "True": 41 test-flag7642: - percentage: 42 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 58 + "True": 42 test-flag7643: - percentage: 43 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 57 + "True": 43 test-flag7644: - percentage: 44 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 56 + "True": 44 test-flag7645: - percentage: 45 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 55 + "True": 45 test-flag7646: - percentage: 46 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 54 + "True": 46 test-flag7647: - percentage: 47 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 53 + "True": 47 test-flag7648: - percentage: 48 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 52 + "True": 48 test-flag7649: - percentage: 49 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 51 + "True": 49 test-flag7650: - percentage: 50 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 50 + "True": 50 test-flag7651: - percentage: 51 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 49 + "True": 51 test-flag7652: - percentage: 52 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 48 + "True": 52 test-flag7653: - percentage: 53 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 47 + "True": 53 test-flag7654: - percentage: 54 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 46 + "True": 54 test-flag7655: - percentage: 55 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 45 + "True": 55 test-flag7656: - percentage: 56 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 44 + "True": 56 test-flag7657: - percentage: 57 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 43 + "True": 57 test-flag7658: - percentage: 58 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 42 + "True": 58 test-flag7659: - percentage: 59 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 41 + "True": 59 test-flag7660: - percentage: 60 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 40 + "True": 60 test-flag7661: - percentage: 61 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 39 + "True": 61 test-flag7662: - percentage: 62 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 38 + "True": 62 test-flag7663: - percentage: 63 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 37 + "True": 63 test-flag7664: - percentage: 64 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 36 + "True": 64 test-flag7665: - percentage: 65 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 35 + "True": 65 test-flag7666: - percentage: 66 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 34 + "True": 66 test-flag7667: - percentage: 67 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 33 + "True": 67 test-flag7668: - percentage: 68 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 32 + "True": 68 test-flag7669: - percentage: 69 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 31 + "True": 69 test-flag7670: - percentage: 70 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 30 + "True": 70 test-flag7671: - percentage: 71 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 29 + "True": 71 test-flag7672: - percentage: 72 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 28 + "True": 72 test-flag7673: - percentage: 73 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 27 + "True": 73 test-flag7674: - percentage: 74 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 26 + "True": 74 test-flag7675: - percentage: 75 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 25 + "True": 75 test-flag7676: - percentage: 76 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 24 + "True": 76 test-flag7677: - percentage: 77 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 23 + "True": 77 test-flag7678: - percentage: 78 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 22 + "True": 78 test-flag7679: - percentage: 79 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 21 + "True": 79 test-flag7680: - percentage: 80 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 20 + "True": 80 test-flag7681: - percentage: 81 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 19 + "True": 81 test-flag7682: - percentage: 82 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 18 + "True": 82 test-flag7683: - percentage: 83 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 17 + "True": 83 test-flag7684: - percentage: 84 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 16 + "True": 84 test-flag7685: - percentage: 85 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 15 + "True": 85 test-flag7686: - percentage: 86 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 14 + "True": 86 test-flag7687: - percentage: 87 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 13 + "True": 87 test-flag7688: - percentage: 88 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 12 + "True": 88 test-flag7689: - percentage: 89 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 11 + "True": 89 test-flag7690: - percentage: 90 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 10 + "True": 90 test-flag7691: - percentage: 91 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 9 + "True": 91 test-flag7692: - percentage: 92 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 8 + "True": 92 test-flag7693: - percentage: 93 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 7 + "True": 93 test-flag7694: - percentage: 94 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 6 + "True": 94 test-flag7695: - percentage: 95 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 5 + "True": 95 test-flag7696: - percentage: 96 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 4 + "True": 96 test-flag7697: - percentage: 97 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 3 + "True": 97 test-flag7698: - percentage: 98 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 2 + "True": 98 test-flag7699: - percentage: 99 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 1 + "True": 99 test-flag7700: - percentage: 0 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 100 + "True": 0 test-flag7701: - percentage: 1 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 99 + "True": 1 test-flag7702: - percentage: 2 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 98 + "True": 2 test-flag7703: - percentage: 3 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 97 + "True": 3 test-flag7704: - percentage: 4 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 96 + "True": 4 test-flag7705: - percentage: 5 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 95 + "True": 5 test-flag7706: - percentage: 6 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 94 + "True": 6 test-flag7707: - percentage: 7 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 93 + "True": 7 test-flag7708: - percentage: 8 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 92 + "True": 8 test-flag7709: - percentage: 9 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 91 + "True": 9 test-flag7710: - percentage: 10 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 90 + "True": 10 test-flag7711: - percentage: 11 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 89 + "True": 11 test-flag7712: - percentage: 12 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 88 + "True": 12 test-flag7713: - percentage: 13 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 87 + "True": 13 test-flag7714: - percentage: 14 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 86 + "True": 14 test-flag7715: - percentage: 15 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 85 + "True": 15 test-flag7716: - percentage: 16 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 84 + "True": 16 test-flag7717: - percentage: 17 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 83 + "True": 17 test-flag7718: - percentage: 18 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 82 + "True": 18 test-flag7719: - percentage: 19 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 81 + "True": 19 test-flag7720: - percentage: 20 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 80 + "True": 20 test-flag7721: - percentage: 21 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 79 + "True": 21 test-flag7722: - percentage: 22 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 78 + "True": 22 test-flag7723: - percentage: 23 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 77 + "True": 23 test-flag7724: - percentage: 24 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 76 + "True": 24 test-flag7725: - percentage: 25 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 75 + "True": 25 test-flag7726: - percentage: 26 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 74 + "True": 26 test-flag7727: - percentage: 27 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 73 + "True": 27 test-flag7728: - percentage: 28 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 72 + "True": 28 test-flag7729: - percentage: 29 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 71 + "True": 29 test-flag7730: - percentage: 30 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 70 + "True": 30 test-flag7731: - percentage: 31 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 69 + "True": 31 test-flag7732: - percentage: 32 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 68 + "True": 32 test-flag7733: - percentage: 33 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 67 + "True": 33 test-flag7734: - percentage: 34 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 66 + "True": 34 test-flag7735: - percentage: 35 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 65 + "True": 35 test-flag7736: - percentage: 36 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 64 + "True": 36 test-flag7737: - percentage: 37 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 63 + "True": 37 test-flag7738: - percentage: 38 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 62 + "True": 38 test-flag7739: - percentage: 39 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 61 + "True": 39 test-flag7740: - percentage: 40 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 60 + "True": 40 test-flag7741: - percentage: 41 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 59 + "True": 41 test-flag7742: - percentage: 42 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 58 + "True": 42 test-flag7743: - percentage: 43 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 57 + "True": 43 test-flag7744: - percentage: 44 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 56 + "True": 44 test-flag7745: - percentage: 45 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 55 + "True": 45 test-flag7746: - percentage: 46 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 54 + "True": 46 test-flag7747: - percentage: 47 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 53 + "True": 47 test-flag7748: - percentage: 48 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 52 + "True": 48 test-flag7749: - percentage: 49 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 51 + "True": 49 test-flag7750: - percentage: 50 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 50 + "True": 50 test-flag7751: - percentage: 51 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 49 + "True": 51 test-flag7752: - percentage: 52 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 48 + "True": 52 test-flag7753: - percentage: 53 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 47 + "True": 53 test-flag7754: - percentage: 54 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 46 + "True": 54 test-flag7755: - percentage: 55 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 45 + "True": 55 test-flag7756: - percentage: 56 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 44 + "True": 56 test-flag7757: - percentage: 57 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 43 + "True": 57 test-flag7758: - percentage: 58 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 42 + "True": 58 test-flag7759: - percentage: 59 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 41 + "True": 59 test-flag7760: - percentage: 60 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 40 + "True": 60 test-flag7761: - percentage: 61 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 39 + "True": 61 test-flag7762: - percentage: 62 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 38 + "True": 62 test-flag7763: - percentage: 63 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 37 + "True": 63 test-flag7764: - percentage: 64 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 36 + "True": 64 test-flag7765: - percentage: 65 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 35 + "True": 65 test-flag7766: - percentage: 66 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 34 + "True": 66 test-flag7767: - percentage: 67 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 33 + "True": 67 test-flag7768: - percentage: 68 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 32 + "True": 68 test-flag7769: - percentage: 69 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 31 + "True": 69 test-flag7770: - percentage: 70 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 30 + "True": 70 test-flag7771: - percentage: 71 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 29 + "True": 71 test-flag7772: - percentage: 72 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 28 + "True": 72 test-flag7773: - percentage: 73 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 27 + "True": 73 test-flag7774: - percentage: 74 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 26 + "True": 74 test-flag7775: - percentage: 75 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 25 + "True": 75 test-flag7776: - percentage: 76 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 24 + "True": 76 test-flag7777: - percentage: 77 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 23 + "True": 77 test-flag7778: - percentage: 78 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 22 + "True": 78 test-flag7779: - percentage: 79 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 21 + "True": 79 test-flag7780: - percentage: 80 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 20 + "True": 80 test-flag7781: - percentage: 81 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 19 + "True": 81 test-flag7782: - percentage: 82 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 18 + "True": 82 test-flag7783: - percentage: 83 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 17 + "True": 83 test-flag7784: - percentage: 84 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 16 + "True": 84 test-flag7785: - percentage: 85 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 15 + "True": 85 test-flag7786: - percentage: 86 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 14 + "True": 86 test-flag7787: - percentage: 87 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 13 + "True": 87 test-flag7788: - percentage: 88 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 12 + "True": 88 test-flag7789: - percentage: 89 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 11 + "True": 89 test-flag7790: - percentage: 90 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 10 + "True": 90 test-flag7791: - percentage: 91 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 9 + "True": 91 test-flag7792: - percentage: 92 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 8 + "True": 92 test-flag7793: - percentage: 93 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 7 + "True": 93 test-flag7794: - percentage: 94 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 6 + "True": 94 test-flag7795: - percentage: 95 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 5 + "True": 95 test-flag7796: - percentage: 96 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 4 + "True": 96 test-flag7797: - percentage: 97 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 3 + "True": 97 test-flag7798: - percentage: 98 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 2 + "True": 98 test-flag7799: - percentage: 99 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 1 + "True": 99 test-flag7800: - percentage: 0 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 100 + "True": 0 test-flag7801: - percentage: 1 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 99 + "True": 1 test-flag7802: - percentage: 2 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 98 + "True": 2 test-flag7803: - percentage: 3 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 97 + "True": 3 test-flag7804: - percentage: 4 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 96 + "True": 4 test-flag7805: - percentage: 5 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 95 + "True": 5 test-flag7806: - percentage: 6 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 94 + "True": 6 test-flag7807: - percentage: 7 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 93 + "True": 7 test-flag7808: - percentage: 8 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 92 + "True": 8 test-flag7809: - percentage: 9 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 91 + "True": 9 test-flag7810: - percentage: 10 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 90 + "True": 10 test-flag7811: - percentage: 11 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 89 + "True": 11 test-flag7812: - percentage: 12 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 88 + "True": 12 test-flag7813: - percentage: 13 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 87 + "True": 13 test-flag7814: - percentage: 14 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 86 + "True": 14 test-flag7815: - percentage: 15 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 85 + "True": 15 test-flag7816: - percentage: 16 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 84 + "True": 16 test-flag7817: - percentage: 17 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 83 + "True": 17 test-flag7818: - percentage: 18 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 82 + "True": 18 test-flag7819: - percentage: 19 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 81 + "True": 19 test-flag7820: - percentage: 20 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 80 + "True": 20 test-flag7821: - percentage: 21 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 79 + "True": 21 test-flag7822: - percentage: 22 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 78 + "True": 22 test-flag7823: - percentage: 23 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 77 + "True": 23 test-flag7824: - percentage: 24 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 76 + "True": 24 test-flag7825: - percentage: 25 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 75 + "True": 25 test-flag7826: - percentage: 26 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 74 + "True": 26 test-flag7827: - percentage: 27 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 73 + "True": 27 test-flag7828: - percentage: 28 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 72 + "True": 28 test-flag7829: - percentage: 29 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 71 + "True": 29 test-flag7830: - percentage: 30 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 70 + "True": 30 test-flag7831: - percentage: 31 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 69 + "True": 31 test-flag7832: - percentage: 32 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 68 + "True": 32 test-flag7833: - percentage: 33 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 67 + "True": 33 test-flag7834: - percentage: 34 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 66 + "True": 34 test-flag7835: - percentage: 35 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 65 + "True": 35 test-flag7836: - percentage: 36 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 64 + "True": 36 test-flag7837: - percentage: 37 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 63 + "True": 37 test-flag7838: - percentage: 38 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 62 + "True": 38 test-flag7839: - percentage: 39 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 61 + "True": 39 test-flag7840: - percentage: 40 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 60 + "True": 40 test-flag7841: - percentage: 41 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 59 + "True": 41 test-flag7842: - percentage: 42 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 58 + "True": 42 test-flag7843: - percentage: 43 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 57 + "True": 43 test-flag7844: - percentage: 44 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 56 + "True": 44 test-flag7845: - percentage: 45 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 55 + "True": 45 test-flag7846: - percentage: 46 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 54 + "True": 46 test-flag7847: - percentage: 47 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 53 + "True": 47 test-flag7848: - percentage: 48 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 52 + "True": 48 test-flag7849: - percentage: 49 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 51 + "True": 49 test-flag7850: - percentage: 50 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 50 + "True": 50 test-flag7851: - percentage: 51 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 49 + "True": 51 test-flag7852: - percentage: 52 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 48 + "True": 52 test-flag7853: - percentage: 53 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 47 + "True": 53 test-flag7854: - percentage: 54 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 46 + "True": 54 test-flag7855: - percentage: 55 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 45 + "True": 55 test-flag7856: - percentage: 56 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 44 + "True": 56 test-flag7857: - percentage: 57 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 43 + "True": 57 test-flag7858: - percentage: 58 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 42 + "True": 58 test-flag7859: - percentage: 59 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 41 + "True": 59 test-flag7860: - percentage: 60 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 40 + "True": 60 test-flag7861: - percentage: 61 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 39 + "True": 61 test-flag7862: - percentage: 62 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 38 + "True": 62 test-flag7863: - percentage: 63 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 37 + "True": 63 test-flag7864: - percentage: 64 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 36 + "True": 64 test-flag7865: - percentage: 65 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 35 + "True": 65 test-flag7866: - percentage: 66 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 34 + "True": 66 test-flag7867: - percentage: 67 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 33 + "True": 67 test-flag7868: - percentage: 68 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 32 + "True": 68 test-flag7869: - percentage: 69 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 31 + "True": 69 test-flag7870: - percentage: 70 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 30 + "True": 70 test-flag7871: - percentage: 71 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 29 + "True": 71 test-flag7872: - percentage: 72 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 28 + "True": 72 test-flag7873: - percentage: 73 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 27 + "True": 73 test-flag7874: - percentage: 74 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 26 + "True": 74 test-flag7875: - percentage: 75 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 25 + "True": 75 test-flag7876: - percentage: 76 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 24 + "True": 76 test-flag7877: - percentage: 77 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 23 + "True": 77 test-flag7878: - percentage: 78 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 22 + "True": 78 test-flag7879: - percentage: 79 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 21 + "True": 79 test-flag7880: - percentage: 80 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 20 + "True": 80 test-flag7881: - percentage: 81 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 19 + "True": 81 test-flag7882: - percentage: 82 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 18 + "True": 82 test-flag7883: - percentage: 83 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 17 + "True": 83 test-flag7884: - percentage: 84 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 16 + "True": 84 test-flag7885: - percentage: 85 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 15 + "True": 85 test-flag7886: - percentage: 86 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 14 + "True": 86 test-flag7887: - percentage: 87 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 13 + "True": 87 test-flag7888: - percentage: 88 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 12 + "True": 88 test-flag7889: - percentage: 89 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 11 + "True": 89 test-flag7890: - percentage: 90 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 10 + "True": 90 test-flag7891: - percentage: 91 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 9 + "True": 91 test-flag7892: - percentage: 92 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 8 + "True": 92 test-flag7893: - percentage: 93 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 7 + "True": 93 test-flag7894: - percentage: 94 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 6 + "True": 94 test-flag7895: - percentage: 95 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 5 + "True": 95 test-flag7896: - percentage: 96 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 4 + "True": 96 test-flag7897: - percentage: 97 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 3 + "True": 97 test-flag7898: - percentage: 98 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 2 + "True": 98 test-flag7899: - percentage: 99 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 1 + "True": 99 test-flag7900: - percentage: 0 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 100 + "True": 0 test-flag7901: - percentage: 1 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 99 + "True": 1 test-flag7902: - percentage: 2 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 98 + "True": 2 test-flag7903: - percentage: 3 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 97 + "True": 3 test-flag7904: - percentage: 4 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 96 + "True": 4 test-flag7905: - percentage: 5 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 95 + "True": 5 test-flag7906: - percentage: 6 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 94 + "True": 6 test-flag7907: - percentage: 7 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 93 + "True": 7 test-flag7908: - percentage: 8 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 92 + "True": 8 test-flag7909: - percentage: 9 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 91 + "True": 9 test-flag7910: - percentage: 10 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 90 + "True": 10 test-flag7911: - percentage: 11 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 89 + "True": 11 test-flag7912: - percentage: 12 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 88 + "True": 12 test-flag7913: - percentage: 13 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 87 + "True": 13 test-flag7914: - percentage: 14 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 86 + "True": 14 test-flag7915: - percentage: 15 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 85 + "True": 15 test-flag7916: - percentage: 16 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 84 + "True": 16 test-flag7917: - percentage: 17 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 83 + "True": 17 test-flag7918: - percentage: 18 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 82 + "True": 18 test-flag7919: - percentage: 19 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 81 + "True": 19 test-flag7920: - percentage: 20 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 80 + "True": 20 test-flag7921: - percentage: 21 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 79 + "True": 21 test-flag7922: - percentage: 22 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 78 + "True": 22 test-flag7923: - percentage: 23 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 77 + "True": 23 test-flag7924: - percentage: 24 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 76 + "True": 24 test-flag7925: - percentage: 25 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 75 + "True": 25 test-flag7926: - percentage: 26 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 74 + "True": 26 test-flag7927: - percentage: 27 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 73 + "True": 27 test-flag7928: - percentage: 28 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 72 + "True": 28 test-flag7929: - percentage: 29 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 71 + "True": 29 test-flag7930: - percentage: 30 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 70 + "True": 30 test-flag7931: - percentage: 31 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 69 + "True": 31 test-flag7932: - percentage: 32 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 68 + "True": 32 test-flag7933: - percentage: 33 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 67 + "True": 33 test-flag7934: - percentage: 34 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 66 + "True": 34 test-flag7935: - percentage: 35 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 65 + "True": 35 test-flag7936: - percentage: 36 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 64 + "True": 36 test-flag7937: - percentage: 37 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 63 + "True": 37 test-flag7938: - percentage: 38 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 62 + "True": 38 test-flag7939: - percentage: 39 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 61 + "True": 39 test-flag7940: - percentage: 40 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 60 + "True": 40 test-flag7941: - percentage: 41 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 59 + "True": 41 test-flag7942: - percentage: 42 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 58 + "True": 42 test-flag7943: - percentage: 43 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 57 + "True": 43 test-flag7944: - percentage: 44 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 56 + "True": 44 test-flag7945: - percentage: 45 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 55 + "True": 45 test-flag7946: - percentage: 46 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 54 + "True": 46 test-flag7947: - percentage: 47 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 53 + "True": 47 test-flag7948: - percentage: 48 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 52 + "True": 48 test-flag7949: - percentage: 49 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 51 + "True": 49 test-flag7950: - percentage: 50 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 50 + "True": 50 test-flag7951: - percentage: 51 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 49 + "True": 51 test-flag7952: - percentage: 52 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 48 + "True": 52 test-flag7953: - percentage: 53 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 47 + "True": 53 test-flag7954: - percentage: 54 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 46 + "True": 54 test-flag7955: - percentage: 55 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 45 + "True": 55 test-flag7956: - percentage: 56 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 44 + "True": 56 test-flag7957: - percentage: 57 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 43 + "True": 57 test-flag7958: - percentage: 58 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 42 + "True": 58 test-flag7959: - percentage: 59 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 41 + "True": 59 test-flag7960: - percentage: 60 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 40 + "True": 60 test-flag7961: - percentage: 61 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 39 + "True": 61 test-flag7962: - percentage: 62 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 38 + "True": 62 test-flag7963: - percentage: 63 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 37 + "True": 63 test-flag7964: - percentage: 64 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 36 + "True": 64 test-flag7965: - percentage: 65 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 35 + "True": 65 test-flag7966: - percentage: 66 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 34 + "True": 66 test-flag7967: - percentage: 67 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 33 + "True": 67 test-flag7968: - percentage: 68 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 32 + "True": 68 test-flag7969: - percentage: 69 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 31 + "True": 69 test-flag7970: - percentage: 70 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 30 + "True": 70 test-flag7971: - percentage: 71 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 29 + "True": 71 test-flag7972: - percentage: 72 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 28 + "True": 72 test-flag7973: - percentage: 73 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 27 + "True": 73 test-flag7974: - percentage: 74 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 26 + "True": 74 test-flag7975: - percentage: 75 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 25 + "True": 75 test-flag7976: - percentage: 76 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 24 + "True": 76 test-flag7977: - percentage: 77 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 23 + "True": 77 test-flag7978: - percentage: 78 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 22 + "True": 78 test-flag7979: - percentage: 79 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 21 + "True": 79 test-flag7980: - percentage: 80 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 20 + "True": 80 test-flag7981: - percentage: 81 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 19 + "True": 81 test-flag7982: - percentage: 82 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 18 + "True": 82 test-flag7983: - percentage: 83 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 17 + "True": 83 test-flag7984: - percentage: 84 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 16 + "True": 84 test-flag7985: - percentage: 85 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 15 + "True": 85 test-flag7986: - percentage: 86 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 14 + "True": 86 test-flag7987: - percentage: 87 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 13 + "True": 87 test-flag7988: - percentage: 88 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 12 + "True": 88 test-flag7989: - percentage: 89 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 11 + "True": 89 test-flag7990: - percentage: 90 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 10 + "True": 90 test-flag7991: - percentage: 91 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 9 + "True": 91 test-flag7992: - percentage: 92 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 8 + "True": 92 test-flag7993: - percentage: 93 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 7 + "True": 93 test-flag7994: - percentage: 94 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 6 + "True": 94 test-flag7995: - percentage: 95 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 5 + "True": 95 test-flag7996: - percentage: 96 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 4 + "True": 96 test-flag7997: - percentage: 97 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 3 + "True": 97 test-flag7998: - percentage: 98 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 2 + "True": 98 test-flag7999: - percentage: 99 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 1 + "True": 99 test-flag8000: - percentage: 0 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 100 + "True": 0 test-flag8001: - percentage: 1 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 99 + "True": 1 test-flag8002: - percentage: 2 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 98 + "True": 2 test-flag8003: - percentage: 3 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 97 + "True": 3 test-flag8004: - percentage: 4 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 96 + "True": 4 test-flag8005: - percentage: 5 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 95 + "True": 5 test-flag8006: - percentage: 6 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 94 + "True": 6 test-flag8007: - percentage: 7 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 93 + "True": 7 test-flag8008: - percentage: 8 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 92 + "True": 8 test-flag8009: - percentage: 9 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 91 + "True": 9 test-flag8010: - percentage: 10 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 90 + "True": 10 test-flag8011: - percentage: 11 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 89 + "True": 11 test-flag8012: - percentage: 12 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 88 + "True": 12 test-flag8013: - percentage: 13 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 87 + "True": 13 test-flag8014: - percentage: 14 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 86 + "True": 14 test-flag8015: - percentage: 15 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 85 + "True": 15 test-flag8016: - percentage: 16 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 84 + "True": 16 test-flag8017: - percentage: 17 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 83 + "True": 17 test-flag8018: - percentage: 18 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 82 + "True": 18 test-flag8019: - percentage: 19 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 81 + "True": 19 test-flag8020: - percentage: 20 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 80 + "True": 20 test-flag8021: - percentage: 21 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 79 + "True": 21 test-flag8022: - percentage: 22 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 78 + "True": 22 test-flag8023: - percentage: 23 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 77 + "True": 23 test-flag8024: - percentage: 24 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 76 + "True": 24 test-flag8025: - percentage: 25 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 75 + "True": 25 test-flag8026: - percentage: 26 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 74 + "True": 26 test-flag8027: - percentage: 27 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 73 + "True": 27 test-flag8028: - percentage: 28 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 72 + "True": 28 test-flag8029: - percentage: 29 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 71 + "True": 29 test-flag8030: - percentage: 30 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 70 + "True": 30 test-flag8031: - percentage: 31 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 69 + "True": 31 test-flag8032: - percentage: 32 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 68 + "True": 32 test-flag8033: - percentage: 33 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 67 + "True": 33 test-flag8034: - percentage: 34 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 66 + "True": 34 test-flag8035: - percentage: 35 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 65 + "True": 35 test-flag8036: - percentage: 36 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 64 + "True": 36 test-flag8037: - percentage: 37 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 63 + "True": 37 test-flag8038: - percentage: 38 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 62 + "True": 38 test-flag8039: - percentage: 39 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 61 + "True": 39 test-flag8040: - percentage: 40 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 60 + "True": 40 test-flag8041: - percentage: 41 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 59 + "True": 41 test-flag8042: - percentage: 42 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 58 + "True": 42 test-flag8043: - percentage: 43 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 57 + "True": 43 test-flag8044: - percentage: 44 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 56 + "True": 44 test-flag8045: - percentage: 45 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 55 + "True": 45 test-flag8046: - percentage: 46 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 54 + "True": 46 test-flag8047: - percentage: 47 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 53 + "True": 47 test-flag8048: - percentage: 48 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 52 + "True": 48 test-flag8049: - percentage: 49 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 51 + "True": 49 test-flag8050: - percentage: 50 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 50 + "True": 50 test-flag8051: - percentage: 51 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 49 + "True": 51 test-flag8052: - percentage: 52 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 48 + "True": 52 test-flag8053: - percentage: 53 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 47 + "True": 53 test-flag8054: - percentage: 54 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 46 + "True": 54 test-flag8055: - percentage: 55 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 45 + "True": 55 test-flag8056: - percentage: 56 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 44 + "True": 56 test-flag8057: - percentage: 57 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 43 + "True": 57 test-flag8058: - percentage: 58 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 42 + "True": 58 test-flag8059: - percentage: 59 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 41 + "True": 59 test-flag8060: - percentage: 60 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 40 + "True": 60 test-flag8061: - percentage: 61 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 39 + "True": 61 test-flag8062: - percentage: 62 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 38 + "True": 62 test-flag8063: - percentage: 63 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 37 + "True": 63 test-flag8064: - percentage: 64 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 36 + "True": 64 test-flag8065: - percentage: 65 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 35 + "True": 65 test-flag8066: - percentage: 66 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 34 + "True": 66 test-flag8067: - percentage: 67 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 33 + "True": 67 test-flag8068: - percentage: 68 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 32 + "True": 68 test-flag8069: - percentage: 69 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 31 + "True": 69 test-flag8070: - percentage: 70 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 30 + "True": 70 test-flag8071: - percentage: 71 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 29 + "True": 71 test-flag8072: - percentage: 72 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 28 + "True": 72 test-flag8073: - percentage: 73 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 27 + "True": 73 test-flag8074: - percentage: 74 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 26 + "True": 74 test-flag8075: - percentage: 75 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 25 + "True": 75 test-flag8076: - percentage: 76 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 24 + "True": 76 test-flag8077: - percentage: 77 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 23 + "True": 77 test-flag8078: - percentage: 78 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 22 + "True": 78 test-flag8079: - percentage: 79 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 21 + "True": 79 test-flag8080: - percentage: 80 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 20 + "True": 80 test-flag8081: - percentage: 81 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 19 + "True": 81 test-flag8082: - percentage: 82 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 18 + "True": 82 test-flag8083: - percentage: 83 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 17 + "True": 83 test-flag8084: - percentage: 84 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 16 + "True": 84 test-flag8085: - percentage: 85 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 15 + "True": 85 test-flag8086: - percentage: 86 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 14 + "True": 86 test-flag8087: - percentage: 87 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 13 + "True": 87 test-flag8088: - percentage: 88 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 12 + "True": 88 test-flag8089: - percentage: 89 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 11 + "True": 89 test-flag8090: - percentage: 90 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 10 + "True": 90 test-flag8091: - percentage: 91 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 9 + "True": 91 test-flag8092: - percentage: 92 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 8 + "True": 92 test-flag8093: - percentage: 93 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 7 + "True": 93 test-flag8094: - percentage: 94 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 6 + "True": 94 test-flag8095: - percentage: 95 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 5 + "True": 95 test-flag8096: - percentage: 96 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 4 + "True": 96 test-flag8097: - percentage: 97 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 3 + "True": 97 test-flag8098: - percentage: 98 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 2 + "True": 98 test-flag8099: - percentage: 99 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 1 + "True": 99 test-flag8100: - percentage: 0 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 100 + "True": 0 test-flag8101: - percentage: 1 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 99 + "True": 1 test-flag8102: - percentage: 2 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 98 + "True": 2 test-flag8103: - percentage: 3 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 97 + "True": 3 test-flag8104: - percentage: 4 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 96 + "True": 4 test-flag8105: - percentage: 5 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 95 + "True": 5 test-flag8106: - percentage: 6 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 94 + "True": 6 test-flag8107: - percentage: 7 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 93 + "True": 7 test-flag8108: - percentage: 8 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 92 + "True": 8 test-flag8109: - percentage: 9 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 91 + "True": 9 test-flag8110: - percentage: 10 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 90 + "True": 10 test-flag8111: - percentage: 11 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 89 + "True": 11 test-flag8112: - percentage: 12 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 88 + "True": 12 test-flag8113: - percentage: 13 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 87 + "True": 13 test-flag8114: - percentage: 14 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 86 + "True": 14 test-flag8115: - percentage: 15 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 85 + "True": 15 test-flag8116: - percentage: 16 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 84 + "True": 16 test-flag8117: - percentage: 17 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 83 + "True": 17 test-flag8118: - percentage: 18 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 82 + "True": 18 test-flag8119: - percentage: 19 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 81 + "True": 19 test-flag8120: - percentage: 20 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 80 + "True": 20 test-flag8121: - percentage: 21 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 79 + "True": 21 test-flag8122: - percentage: 22 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 78 + "True": 22 test-flag8123: - percentage: 23 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 77 + "True": 23 test-flag8124: - percentage: 24 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 76 + "True": 24 test-flag8125: - percentage: 25 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 75 + "True": 25 test-flag8126: - percentage: 26 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 74 + "True": 26 test-flag8127: - percentage: 27 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 73 + "True": 27 test-flag8128: - percentage: 28 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 72 + "True": 28 test-flag8129: - percentage: 29 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 71 + "True": 29 test-flag8130: - percentage: 30 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 70 + "True": 30 test-flag8131: - percentage: 31 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 69 + "True": 31 test-flag8132: - percentage: 32 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 68 + "True": 32 test-flag8133: - percentage: 33 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 67 + "True": 33 test-flag8134: - percentage: 34 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 66 + "True": 34 test-flag8135: - percentage: 35 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 65 + "True": 35 test-flag8136: - percentage: 36 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 64 + "True": 36 test-flag8137: - percentage: 37 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 63 + "True": 37 test-flag8138: - percentage: 38 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 62 + "True": 38 test-flag8139: - percentage: 39 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 61 + "True": 39 test-flag8140: - percentage: 40 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 60 + "True": 40 test-flag8141: - percentage: 41 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 59 + "True": 41 test-flag8142: - percentage: 42 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 58 + "True": 42 test-flag8143: - percentage: 43 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 57 + "True": 43 test-flag8144: - percentage: 44 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 56 + "True": 44 test-flag8145: - percentage: 45 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 55 + "True": 45 test-flag8146: - percentage: 46 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 54 + "True": 46 test-flag8147: - percentage: 47 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 53 + "True": 47 test-flag8148: - percentage: 48 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 52 + "True": 48 test-flag8149: - percentage: 49 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 51 + "True": 49 test-flag8150: - percentage: 50 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 50 + "True": 50 test-flag8151: - percentage: 51 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 49 + "True": 51 test-flag8152: - percentage: 52 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 48 + "True": 52 test-flag8153: - percentage: 53 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 47 + "True": 53 test-flag8154: - percentage: 54 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 46 + "True": 54 test-flag8155: - percentage: 55 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 45 + "True": 55 test-flag8156: - percentage: 56 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 44 + "True": 56 test-flag8157: - percentage: 57 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 43 + "True": 57 test-flag8158: - percentage: 58 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 42 + "True": 58 test-flag8159: - percentage: 59 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 41 + "True": 59 test-flag8160: - percentage: 60 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 40 + "True": 60 test-flag8161: - percentage: 61 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 39 + "True": 61 test-flag8162: - percentage: 62 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 38 + "True": 62 test-flag8163: - percentage: 63 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 37 + "True": 63 test-flag8164: - percentage: 64 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 36 + "True": 64 test-flag8165: - percentage: 65 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 35 + "True": 65 test-flag8166: - percentage: 66 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 34 + "True": 66 test-flag8167: - percentage: 67 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 33 + "True": 67 test-flag8168: - percentage: 68 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 32 + "True": 68 test-flag8169: - percentage: 69 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 31 + "True": 69 test-flag8170: - percentage: 70 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 30 + "True": 70 test-flag8171: - percentage: 71 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 29 + "True": 71 test-flag8172: - percentage: 72 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 28 + "True": 72 test-flag8173: - percentage: 73 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 27 + "True": 73 test-flag8174: - percentage: 74 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 26 + "True": 74 test-flag8175: - percentage: 75 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 25 + "True": 75 test-flag8176: - percentage: 76 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 24 + "True": 76 test-flag8177: - percentage: 77 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 23 + "True": 77 test-flag8178: - percentage: 78 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 22 + "True": 78 test-flag8179: - percentage: 79 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 21 + "True": 79 test-flag8180: - percentage: 80 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 20 + "True": 80 test-flag8181: - percentage: 81 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 19 + "True": 81 test-flag8182: - percentage: 82 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 18 + "True": 82 test-flag8183: - percentage: 83 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 17 + "True": 83 test-flag8184: - percentage: 84 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 16 + "True": 84 test-flag8185: - percentage: 85 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 15 + "True": 85 test-flag8186: - percentage: 86 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 14 + "True": 86 test-flag8187: - percentage: 87 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 13 + "True": 87 test-flag8188: - percentage: 88 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 12 + "True": 88 test-flag8189: - percentage: 89 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 11 + "True": 89 test-flag8190: - percentage: 90 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 10 + "True": 90 test-flag8191: - percentage: 91 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 9 + "True": 91 test-flag8192: - percentage: 92 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 8 + "True": 92 test-flag8193: - percentage: 93 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 7 + "True": 93 test-flag8194: - percentage: 94 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 6 + "True": 94 test-flag8195: - percentage: 95 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 5 + "True": 95 test-flag8196: - percentage: 96 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 4 + "True": 96 test-flag8197: - percentage: 97 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 3 + "True": 97 test-flag8198: - percentage: 98 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 2 + "True": 98 test-flag8199: - percentage: 99 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 1 + "True": 99 test-flag8200: - percentage: 0 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 100 + "True": 0 test-flag8201: - percentage: 1 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 99 + "True": 1 test-flag8202: - percentage: 2 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 98 + "True": 2 test-flag8203: - percentage: 3 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 97 + "True": 3 test-flag8204: - percentage: 4 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 96 + "True": 4 test-flag8205: - percentage: 5 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 95 + "True": 5 test-flag8206: - percentage: 6 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 94 + "True": 6 test-flag8207: - percentage: 7 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 93 + "True": 7 test-flag8208: - percentage: 8 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 92 + "True": 8 test-flag8209: - percentage: 9 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 91 + "True": 9 test-flag8210: - percentage: 10 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 90 + "True": 10 test-flag8211: - percentage: 11 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 89 + "True": 11 test-flag8212: - percentage: 12 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 88 + "True": 12 test-flag8213: - percentage: 13 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 87 + "True": 13 test-flag8214: - percentage: 14 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 86 + "True": 14 test-flag8215: - percentage: 15 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 85 + "True": 15 test-flag8216: - percentage: 16 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 84 + "True": 16 test-flag8217: - percentage: 17 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 83 + "True": 17 test-flag8218: - percentage: 18 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 82 + "True": 18 test-flag8219: - percentage: 19 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 81 + "True": 19 test-flag8220: - percentage: 20 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 80 + "True": 20 test-flag8221: - percentage: 21 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 79 + "True": 21 test-flag8222: - percentage: 22 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 78 + "True": 22 test-flag8223: - percentage: 23 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 77 + "True": 23 test-flag8224: - percentage: 24 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 76 + "True": 24 test-flag8225: - percentage: 25 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 75 + "True": 25 test-flag8226: - percentage: 26 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 74 + "True": 26 test-flag8227: - percentage: 27 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 73 + "True": 27 test-flag8228: - percentage: 28 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 72 + "True": 28 test-flag8229: - percentage: 29 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 71 + "True": 29 test-flag8230: - percentage: 30 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 70 + "True": 30 test-flag8231: - percentage: 31 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 69 + "True": 31 test-flag8232: - percentage: 32 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 68 + "True": 32 test-flag8233: - percentage: 33 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 67 + "True": 33 test-flag8234: - percentage: 34 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 66 + "True": 34 test-flag8235: - percentage: 35 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 65 + "True": 35 test-flag8236: - percentage: 36 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 64 + "True": 36 test-flag8237: - percentage: 37 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 63 + "True": 37 test-flag8238: - percentage: 38 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 62 + "True": 38 test-flag8239: - percentage: 39 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 61 + "True": 39 test-flag8240: - percentage: 40 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 60 + "True": 40 test-flag8241: - percentage: 41 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 59 + "True": 41 test-flag8242: - percentage: 42 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 58 + "True": 42 test-flag8243: - percentage: 43 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 57 + "True": 43 test-flag8244: - percentage: 44 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 56 + "True": 44 test-flag8245: - percentage: 45 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 55 + "True": 45 test-flag8246: - percentage: 46 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 54 + "True": 46 test-flag8247: - percentage: 47 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 53 + "True": 47 test-flag8248: - percentage: 48 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 52 + "True": 48 test-flag8249: - percentage: 49 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 51 + "True": 49 test-flag8250: - percentage: 50 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 50 + "True": 50 test-flag8251: - percentage: 51 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 49 + "True": 51 test-flag8252: - percentage: 52 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 48 + "True": 52 test-flag8253: - percentage: 53 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 47 + "True": 53 test-flag8254: - percentage: 54 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 46 + "True": 54 test-flag8255: - percentage: 55 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 45 + "True": 55 test-flag8256: - percentage: 56 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 44 + "True": 56 test-flag8257: - percentage: 57 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 43 + "True": 57 test-flag8258: - percentage: 58 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 42 + "True": 58 test-flag8259: - percentage: 59 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 41 + "True": 59 test-flag8260: - percentage: 60 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 40 + "True": 60 test-flag8261: - percentage: 61 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 39 + "True": 61 test-flag8262: - percentage: 62 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 38 + "True": 62 test-flag8263: - percentage: 63 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 37 + "True": 63 test-flag8264: - percentage: 64 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 36 + "True": 64 test-flag8265: - percentage: 65 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 35 + "True": 65 test-flag8266: - percentage: 66 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 34 + "True": 66 test-flag8267: - percentage: 67 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 33 + "True": 67 test-flag8268: - percentage: 68 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 32 + "True": 68 test-flag8269: - percentage: 69 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 31 + "True": 69 test-flag8270: - percentage: 70 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 30 + "True": 70 test-flag8271: - percentage: 71 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 29 + "True": 71 test-flag8272: - percentage: 72 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 28 + "True": 72 test-flag8273: - percentage: 73 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 27 + "True": 73 test-flag8274: - percentage: 74 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 26 + "True": 74 test-flag8275: - percentage: 75 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 25 + "True": 75 test-flag8276: - percentage: 76 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 24 + "True": 76 test-flag8277: - percentage: 77 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 23 + "True": 77 test-flag8278: - percentage: 78 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 22 + "True": 78 test-flag8279: - percentage: 79 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 21 + "True": 79 test-flag8280: - percentage: 80 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 20 + "True": 80 test-flag8281: - percentage: 81 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 19 + "True": 81 test-flag8282: - percentage: 82 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 18 + "True": 82 test-flag8283: - percentage: 83 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 17 + "True": 83 test-flag8284: - percentage: 84 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 16 + "True": 84 test-flag8285: - percentage: 85 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 15 + "True": 85 test-flag8286: - percentage: 86 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 14 + "True": 86 test-flag8287: - percentage: 87 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 13 + "True": 87 test-flag8288: - percentage: 88 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 12 + "True": 88 test-flag8289: - percentage: 89 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 11 + "True": 89 test-flag8290: - percentage: 90 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 10 + "True": 90 test-flag8291: - percentage: 91 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 9 + "True": 91 test-flag8292: - percentage: 92 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 8 + "True": 92 test-flag8293: - percentage: 93 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 7 + "True": 93 test-flag8294: - percentage: 94 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 6 + "True": 94 test-flag8295: - percentage: 95 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 5 + "True": 95 test-flag8296: - percentage: 96 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 4 + "True": 96 test-flag8297: - percentage: 97 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 3 + "True": 97 test-flag8298: - percentage: 98 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 2 + "True": 98 test-flag8299: - percentage: 99 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 1 + "True": 99 test-flag8300: - percentage: 0 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 100 + "True": 0 test-flag8301: - percentage: 1 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 99 + "True": 1 test-flag8302: - percentage: 2 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 98 + "True": 2 test-flag8303: - percentage: 3 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 97 + "True": 3 test-flag8304: - percentage: 4 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 96 + "True": 4 test-flag8305: - percentage: 5 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 95 + "True": 5 test-flag8306: - percentage: 6 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 94 + "True": 6 test-flag8307: - percentage: 7 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 93 + "True": 7 test-flag8308: - percentage: 8 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 92 + "True": 8 test-flag8309: - percentage: 9 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 91 + "True": 9 test-flag8310: - percentage: 10 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 90 + "True": 10 test-flag8311: - percentage: 11 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 89 + "True": 11 test-flag8312: - percentage: 12 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 88 + "True": 12 test-flag8313: - percentage: 13 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 87 + "True": 13 test-flag8314: - percentage: 14 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 86 + "True": 14 test-flag8315: - percentage: 15 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 85 + "True": 15 test-flag8316: - percentage: 16 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 84 + "True": 16 test-flag8317: - percentage: 17 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 83 + "True": 17 test-flag8318: - percentage: 18 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 82 + "True": 18 test-flag8319: - percentage: 19 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 81 + "True": 19 test-flag8320: - percentage: 20 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 80 + "True": 20 test-flag8321: - percentage: 21 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 79 + "True": 21 test-flag8322: - percentage: 22 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 78 + "True": 22 test-flag8323: - percentage: 23 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 77 + "True": 23 test-flag8324: - percentage: 24 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 76 + "True": 24 test-flag8325: - percentage: 25 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 75 + "True": 25 test-flag8326: - percentage: 26 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 74 + "True": 26 test-flag8327: - percentage: 27 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 73 + "True": 27 test-flag8328: - percentage: 28 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 72 + "True": 28 test-flag8329: - percentage: 29 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 71 + "True": 29 test-flag8330: - percentage: 30 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 70 + "True": 30 test-flag8331: - percentage: 31 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 69 + "True": 31 test-flag8332: - percentage: 32 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 68 + "True": 32 test-flag8333: - percentage: 33 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 67 + "True": 33 test-flag8334: - percentage: 34 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 66 + "True": 34 test-flag8335: - percentage: 35 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 65 + "True": 35 test-flag8336: - percentage: 36 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 64 + "True": 36 test-flag8337: - percentage: 37 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 63 + "True": 37 test-flag8338: - percentage: 38 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 62 + "True": 38 test-flag8339: - percentage: 39 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 61 + "True": 39 test-flag8340: - percentage: 40 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 60 + "True": 40 test-flag8341: - percentage: 41 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 59 + "True": 41 test-flag8342: - percentage: 42 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 58 + "True": 42 test-flag8343: - percentage: 43 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 57 + "True": 43 test-flag8344: - percentage: 44 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 56 + "True": 44 test-flag8345: - percentage: 45 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 55 + "True": 45 test-flag8346: - percentage: 46 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 54 + "True": 46 test-flag8347: - percentage: 47 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 53 + "True": 47 test-flag8348: - percentage: 48 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 52 + "True": 48 test-flag8349: - percentage: 49 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 51 + "True": 49 test-flag8350: - percentage: 50 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 50 + "True": 50 test-flag8351: - percentage: 51 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 49 + "True": 51 test-flag8352: - percentage: 52 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 48 + "True": 52 test-flag8353: - percentage: 53 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 47 + "True": 53 test-flag8354: - percentage: 54 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 46 + "True": 54 test-flag8355: - percentage: 55 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 45 + "True": 55 test-flag8356: - percentage: 56 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 44 + "True": 56 test-flag8357: - percentage: 57 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 43 + "True": 57 test-flag8358: - percentage: 58 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 42 + "True": 58 test-flag8359: - percentage: 59 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 41 + "True": 59 test-flag8360: - percentage: 60 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 40 + "True": 60 test-flag8361: - percentage: 61 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 39 + "True": 61 test-flag8362: - percentage: 62 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 38 + "True": 62 test-flag8363: - percentage: 63 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 37 + "True": 63 test-flag8364: - percentage: 64 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 36 + "True": 64 test-flag8365: - percentage: 65 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 35 + "True": 65 test-flag8366: - percentage: 66 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 34 + "True": 66 test-flag8367: - percentage: 67 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 33 + "True": 67 test-flag8368: - percentage: 68 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 32 + "True": 68 test-flag8369: - percentage: 69 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 31 + "True": 69 test-flag8370: - percentage: 70 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 30 + "True": 70 test-flag8371: - percentage: 71 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 29 + "True": 71 test-flag8372: - percentage: 72 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 28 + "True": 72 test-flag8373: - percentage: 73 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 27 + "True": 73 test-flag8374: - percentage: 74 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 26 + "True": 74 test-flag8375: - percentage: 75 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 25 + "True": 75 test-flag8376: - percentage: 76 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 24 + "True": 76 test-flag8377: - percentage: 77 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 23 + "True": 77 test-flag8378: - percentage: 78 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 22 + "True": 78 test-flag8379: - percentage: 79 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 21 + "True": 79 test-flag8380: - percentage: 80 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 20 + "True": 80 test-flag8381: - percentage: 81 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 19 + "True": 81 test-flag8382: - percentage: 82 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 18 + "True": 82 test-flag8383: - percentage: 83 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 17 + "True": 83 test-flag8384: - percentage: 84 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 16 + "True": 84 test-flag8385: - percentage: 85 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 15 + "True": 85 test-flag8386: - percentage: 86 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 14 + "True": 86 test-flag8387: - percentage: 87 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 13 + "True": 87 test-flag8388: - percentage: 88 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 12 + "True": 88 test-flag8389: - percentage: 89 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 11 + "True": 89 test-flag8390: - percentage: 90 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 10 + "True": 90 test-flag8391: - percentage: 91 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 9 + "True": 91 test-flag8392: - percentage: 92 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 8 + "True": 92 test-flag8393: - percentage: 93 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 7 + "True": 93 test-flag8394: - percentage: 94 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 6 + "True": 94 test-flag8395: - percentage: 95 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 5 + "True": 95 test-flag8396: - percentage: 96 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 4 + "True": 96 test-flag8397: - percentage: 97 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 3 + "True": 97 test-flag8398: - percentage: 98 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 2 + "True": 98 test-flag8399: - percentage: 99 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 1 + "True": 99 test-flag8400: - percentage: 0 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 100 + "True": 0 test-flag8401: - percentage: 1 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 99 + "True": 1 test-flag8402: - percentage: 2 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 98 + "True": 2 test-flag8403: - percentage: 3 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 97 + "True": 3 test-flag8404: - percentage: 4 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 96 + "True": 4 test-flag8405: - percentage: 5 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 95 + "True": 5 test-flag8406: - percentage: 6 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 94 + "True": 6 test-flag8407: - percentage: 7 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 93 + "True": 7 test-flag8408: - percentage: 8 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 92 + "True": 8 test-flag8409: - percentage: 9 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 91 + "True": 9 test-flag8410: - percentage: 10 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 90 + "True": 10 test-flag8411: - percentage: 11 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 89 + "True": 11 test-flag8412: - percentage: 12 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 88 + "True": 12 test-flag8413: - percentage: 13 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 87 + "True": 13 test-flag8414: - percentage: 14 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 86 + "True": 14 test-flag8415: - percentage: 15 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 85 + "True": 15 test-flag8416: - percentage: 16 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 84 + "True": 16 test-flag8417: - percentage: 17 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 83 + "True": 17 test-flag8418: - percentage: 18 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 82 + "True": 18 test-flag8419: - percentage: 19 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 81 + "True": 19 test-flag8420: - percentage: 20 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 80 + "True": 20 test-flag8421: - percentage: 21 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 79 + "True": 21 test-flag8422: - percentage: 22 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 78 + "True": 22 test-flag8423: - percentage: 23 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 77 + "True": 23 test-flag8424: - percentage: 24 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 76 + "True": 24 test-flag8425: - percentage: 25 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 75 + "True": 25 test-flag8426: - percentage: 26 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 74 + "True": 26 test-flag8427: - percentage: 27 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 73 + "True": 27 test-flag8428: - percentage: 28 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 72 + "True": 28 test-flag8429: - percentage: 29 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 71 + "True": 29 test-flag8430: - percentage: 30 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 70 + "True": 30 test-flag8431: - percentage: 31 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 69 + "True": 31 test-flag8432: - percentage: 32 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 68 + "True": 32 test-flag8433: - percentage: 33 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 67 + "True": 33 test-flag8434: - percentage: 34 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 66 + "True": 34 test-flag8435: - percentage: 35 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 65 + "True": 35 test-flag8436: - percentage: 36 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 64 + "True": 36 test-flag8437: - percentage: 37 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 63 + "True": 37 test-flag8438: - percentage: 38 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 62 + "True": 38 test-flag8439: - percentage: 39 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 61 + "True": 39 test-flag8440: - percentage: 40 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 60 + "True": 40 test-flag8441: - percentage: 41 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 59 + "True": 41 test-flag8442: - percentage: 42 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 58 + "True": 42 test-flag8443: - percentage: 43 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 57 + "True": 43 test-flag8444: - percentage: 44 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 56 + "True": 44 test-flag8445: - percentage: 45 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 55 + "True": 45 test-flag8446: - percentage: 46 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 54 + "True": 46 test-flag8447: - percentage: 47 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 53 + "True": 47 test-flag8448: - percentage: 48 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 52 + "True": 48 test-flag8449: - percentage: 49 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 51 + "True": 49 test-flag8450: - percentage: 50 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 50 + "True": 50 test-flag8451: - percentage: 51 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 49 + "True": 51 test-flag8452: - percentage: 52 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 48 + "True": 52 test-flag8453: - percentage: 53 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 47 + "True": 53 test-flag8454: - percentage: 54 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 46 + "True": 54 test-flag8455: - percentage: 55 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 45 + "True": 55 test-flag8456: - percentage: 56 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 44 + "True": 56 test-flag8457: - percentage: 57 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 43 + "True": 57 test-flag8458: - percentage: 58 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 42 + "True": 58 test-flag8459: - percentage: 59 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 41 + "True": 59 test-flag8460: - percentage: 60 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 40 + "True": 60 test-flag8461: - percentage: 61 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 39 + "True": 61 test-flag8462: - percentage: 62 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 38 + "True": 62 test-flag8463: - percentage: 63 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 37 + "True": 63 test-flag8464: - percentage: 64 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 36 + "True": 64 test-flag8465: - percentage: 65 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 35 + "True": 65 test-flag8466: - percentage: 66 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 34 + "True": 66 test-flag8467: - percentage: 67 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 33 + "True": 67 test-flag8468: - percentage: 68 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 32 + "True": 68 test-flag8469: - percentage: 69 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 31 + "True": 69 test-flag8470: - percentage: 70 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 30 + "True": 70 test-flag8471: - percentage: 71 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 29 + "True": 71 test-flag8472: - percentage: 72 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 28 + "True": 72 test-flag8473: - percentage: 73 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 27 + "True": 73 test-flag8474: - percentage: 74 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 26 + "True": 74 test-flag8475: - percentage: 75 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 25 + "True": 75 test-flag8476: - percentage: 76 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 24 + "True": 76 test-flag8477: - percentage: 77 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 23 + "True": 77 test-flag8478: - percentage: 78 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 22 + "True": 78 test-flag8479: - percentage: 79 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 21 + "True": 79 test-flag8480: - percentage: 80 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 20 + "True": 80 test-flag8481: - percentage: 81 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 19 + "True": 81 test-flag8482: - percentage: 82 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 18 + "True": 82 test-flag8483: - percentage: 83 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 17 + "True": 83 test-flag8484: - percentage: 84 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 16 + "True": 84 test-flag8485: - percentage: 85 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 15 + "True": 85 test-flag8486: - percentage: 86 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 14 + "True": 86 test-flag8487: - percentage: 87 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 13 + "True": 87 test-flag8488: - percentage: 88 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 12 + "True": 88 test-flag8489: - percentage: 89 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 11 + "True": 89 test-flag8490: - percentage: 90 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 10 + "True": 90 test-flag8491: - percentage: 91 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 9 + "True": 91 test-flag8492: - percentage: 92 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 8 + "True": 92 test-flag8493: - percentage: 93 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 7 + "True": 93 test-flag8494: - percentage: 94 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 6 + "True": 94 test-flag8495: - percentage: 95 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 5 + "True": 95 test-flag8496: - percentage: 96 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 4 + "True": 96 test-flag8497: - percentage: 97 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 3 + "True": 97 test-flag8498: - percentage: 98 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 2 + "True": 98 test-flag8499: - percentage: 99 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 1 + "True": 99 test-flag8500: - percentage: 0 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 100 + "True": 0 test-flag8501: - percentage: 1 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 99 + "True": 1 test-flag8502: - percentage: 2 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 98 + "True": 2 test-flag8503: - percentage: 3 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 97 + "True": 3 test-flag8504: - percentage: 4 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 96 + "True": 4 test-flag8505: - percentage: 5 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 95 + "True": 5 test-flag8506: - percentage: 6 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 94 + "True": 6 test-flag8507: - percentage: 7 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 93 + "True": 7 test-flag8508: - percentage: 8 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 92 + "True": 8 test-flag8509: - percentage: 9 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 91 + "True": 9 test-flag8510: - percentage: 10 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 90 + "True": 10 test-flag8511: - percentage: 11 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 89 + "True": 11 test-flag8512: - percentage: 12 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 88 + "True": 12 test-flag8513: - percentage: 13 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 87 + "True": 13 test-flag8514: - percentage: 14 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 86 + "True": 14 test-flag8515: - percentage: 15 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 85 + "True": 15 test-flag8516: - percentage: 16 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 84 + "True": 16 test-flag8517: - percentage: 17 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 83 + "True": 17 test-flag8518: - percentage: 18 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 82 + "True": 18 test-flag8519: - percentage: 19 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 81 + "True": 19 test-flag8520: - percentage: 20 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 80 + "True": 20 test-flag8521: - percentage: 21 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 79 + "True": 21 test-flag8522: - percentage: 22 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 78 + "True": 22 test-flag8523: - percentage: 23 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 77 + "True": 23 test-flag8524: - percentage: 24 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 76 + "True": 24 test-flag8525: - percentage: 25 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 75 + "True": 25 test-flag8526: - percentage: 26 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 74 + "True": 26 test-flag8527: - percentage: 27 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 73 + "True": 27 test-flag8528: - percentage: 28 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 72 + "True": 28 test-flag8529: - percentage: 29 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 71 + "True": 29 test-flag8530: - percentage: 30 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 70 + "True": 30 test-flag8531: - percentage: 31 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 69 + "True": 31 test-flag8532: - percentage: 32 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 68 + "True": 32 test-flag8533: - percentage: 33 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 67 + "True": 33 test-flag8534: - percentage: 34 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 66 + "True": 34 test-flag8535: - percentage: 35 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 65 + "True": 35 test-flag8536: - percentage: 36 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 64 + "True": 36 test-flag8537: - percentage: 37 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 63 + "True": 37 test-flag8538: - percentage: 38 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 62 + "True": 38 test-flag8539: - percentage: 39 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 61 + "True": 39 test-flag8540: - percentage: 40 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 60 + "True": 40 test-flag8541: - percentage: 41 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 59 + "True": 41 test-flag8542: - percentage: 42 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 58 + "True": 42 test-flag8543: - percentage: 43 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 57 + "True": 43 test-flag8544: - percentage: 44 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 56 + "True": 44 test-flag8545: - percentage: 45 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 55 + "True": 45 test-flag8546: - percentage: 46 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 54 + "True": 46 test-flag8547: - percentage: 47 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 53 + "True": 47 test-flag8548: - percentage: 48 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 52 + "True": 48 test-flag8549: - percentage: 49 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 51 + "True": 49 test-flag8550: - percentage: 50 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 50 + "True": 50 test-flag8551: - percentage: 51 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 49 + "True": 51 test-flag8552: - percentage: 52 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 48 + "True": 52 test-flag8553: - percentage: 53 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 47 + "True": 53 test-flag8554: - percentage: 54 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 46 + "True": 54 test-flag8555: - percentage: 55 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 45 + "True": 55 test-flag8556: - percentage: 56 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 44 + "True": 56 test-flag8557: - percentage: 57 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 43 + "True": 57 test-flag8558: - percentage: 58 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 42 + "True": 58 test-flag8559: - percentage: 59 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 41 + "True": 59 test-flag8560: - percentage: 60 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 40 + "True": 60 test-flag8561: - percentage: 61 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 39 + "True": 61 test-flag8562: - percentage: 62 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 38 + "True": 62 test-flag8563: - percentage: 63 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 37 + "True": 63 test-flag8564: - percentage: 64 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 36 + "True": 64 test-flag8565: - percentage: 65 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 35 + "True": 65 test-flag8566: - percentage: 66 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 34 + "True": 66 test-flag8567: - percentage: 67 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 33 + "True": 67 test-flag8568: - percentage: 68 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 32 + "True": 68 test-flag8569: - percentage: 69 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 31 + "True": 69 test-flag8570: - percentage: 70 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 30 + "True": 70 test-flag8571: - percentage: 71 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 29 + "True": 71 test-flag8572: - percentage: 72 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 28 + "True": 72 test-flag8573: - percentage: 73 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 27 + "True": 73 test-flag8574: - percentage: 74 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 26 + "True": 74 test-flag8575: - percentage: 75 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 25 + "True": 75 test-flag8576: - percentage: 76 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 24 + "True": 76 test-flag8577: - percentage: 77 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 23 + "True": 77 test-flag8578: - percentage: 78 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 22 + "True": 78 test-flag8579: - percentage: 79 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 21 + "True": 79 test-flag8580: - percentage: 80 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 20 + "True": 80 test-flag8581: - percentage: 81 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 19 + "True": 81 test-flag8582: - percentage: 82 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 18 + "True": 82 test-flag8583: - percentage: 83 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 17 + "True": 83 test-flag8584: - percentage: 84 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 16 + "True": 84 test-flag8585: - percentage: 85 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 15 + "True": 85 test-flag8586: - percentage: 86 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 14 + "True": 86 test-flag8587: - percentage: 87 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 13 + "True": 87 test-flag8588: - percentage: 88 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 12 + "True": 88 test-flag8589: - percentage: 89 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 11 + "True": 89 test-flag8590: - percentage: 90 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 10 + "True": 90 test-flag8591: - percentage: 91 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 9 + "True": 91 test-flag8592: - percentage: 92 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 8 + "True": 92 test-flag8593: - percentage: 93 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 7 + "True": 93 test-flag8594: - percentage: 94 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 6 + "True": 94 test-flag8595: - percentage: 95 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 5 + "True": 95 test-flag8596: - percentage: 96 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 4 + "True": 96 test-flag8597: - percentage: 97 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 3 + "True": 97 test-flag8598: - percentage: 98 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 2 + "True": 98 test-flag8599: - percentage: 99 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 1 + "True": 99 test-flag8600: - percentage: 0 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 100 + "True": 0 test-flag8601: - percentage: 1 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 99 + "True": 1 test-flag8602: - percentage: 2 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 98 + "True": 2 test-flag8603: - percentage: 3 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 97 + "True": 3 test-flag8604: - percentage: 4 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 96 + "True": 4 test-flag8605: - percentage: 5 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 95 + "True": 5 test-flag8606: - percentage: 6 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 94 + "True": 6 test-flag8607: - percentage: 7 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 93 + "True": 7 test-flag8608: - percentage: 8 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 92 + "True": 8 test-flag8609: - percentage: 9 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 91 + "True": 9 test-flag8610: - percentage: 10 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 90 + "True": 10 test-flag8611: - percentage: 11 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 89 + "True": 11 test-flag8612: - percentage: 12 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 88 + "True": 12 test-flag8613: - percentage: 13 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 87 + "True": 13 test-flag8614: - percentage: 14 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 86 + "True": 14 test-flag8615: - percentage: 15 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 85 + "True": 15 test-flag8616: - percentage: 16 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 84 + "True": 16 test-flag8617: - percentage: 17 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 83 + "True": 17 test-flag8618: - percentage: 18 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 82 + "True": 18 test-flag8619: - percentage: 19 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 81 + "True": 19 test-flag8620: - percentage: 20 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 80 + "True": 20 test-flag8621: - percentage: 21 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 79 + "True": 21 test-flag8622: - percentage: 22 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 78 + "True": 22 test-flag8623: - percentage: 23 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 77 + "True": 23 test-flag8624: - percentage: 24 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 76 + "True": 24 test-flag8625: - percentage: 25 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 75 + "True": 25 test-flag8626: - percentage: 26 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 74 + "True": 26 test-flag8627: - percentage: 27 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 73 + "True": 27 test-flag8628: - percentage: 28 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 72 + "True": 28 test-flag8629: - percentage: 29 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 71 + "True": 29 test-flag8630: - percentage: 30 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 70 + "True": 30 test-flag8631: - percentage: 31 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 69 + "True": 31 test-flag8632: - percentage: 32 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 68 + "True": 32 test-flag8633: - percentage: 33 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 67 + "True": 33 test-flag8634: - percentage: 34 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 66 + "True": 34 test-flag8635: - percentage: 35 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 65 + "True": 35 test-flag8636: - percentage: 36 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 64 + "True": 36 test-flag8637: - percentage: 37 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 63 + "True": 37 test-flag8638: - percentage: 38 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 62 + "True": 38 test-flag8639: - percentage: 39 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 61 + "True": 39 test-flag8640: - percentage: 40 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 60 + "True": 40 test-flag8641: - percentage: 41 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 59 + "True": 41 test-flag8642: - percentage: 42 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 58 + "True": 42 test-flag8643: - percentage: 43 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 57 + "True": 43 test-flag8644: - percentage: 44 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 56 + "True": 44 test-flag8645: - percentage: 45 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 55 + "True": 45 test-flag8646: - percentage: 46 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 54 + "True": 46 test-flag8647: - percentage: 47 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 53 + "True": 47 test-flag8648: - percentage: 48 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 52 + "True": 48 test-flag8649: - percentage: 49 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 51 + "True": 49 test-flag8650: - percentage: 50 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 50 + "True": 50 test-flag8651: - percentage: 51 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 49 + "True": 51 test-flag8652: - percentage: 52 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 48 + "True": 52 test-flag8653: - percentage: 53 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 47 + "True": 53 test-flag8654: - percentage: 54 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 46 + "True": 54 test-flag8655: - percentage: 55 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 45 + "True": 55 test-flag8656: - percentage: 56 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 44 + "True": 56 test-flag8657: - percentage: 57 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 43 + "True": 57 test-flag8658: - percentage: 58 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 42 + "True": 58 test-flag8659: - percentage: 59 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 41 + "True": 59 test-flag8660: - percentage: 60 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 40 + "True": 60 test-flag8661: - percentage: 61 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 39 + "True": 61 test-flag8662: - percentage: 62 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 38 + "True": 62 test-flag8663: - percentage: 63 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 37 + "True": 63 test-flag8664: - percentage: 64 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 36 + "True": 64 test-flag8665: - percentage: 65 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 35 + "True": 65 test-flag8666: - percentage: 66 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 34 + "True": 66 test-flag8667: - percentage: 67 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 33 + "True": 67 test-flag8668: - percentage: 68 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 32 + "True": 68 test-flag8669: - percentage: 69 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 31 + "True": 69 test-flag8670: - percentage: 70 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 30 + "True": 70 test-flag8671: - percentage: 71 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 29 + "True": 71 test-flag8672: - percentage: 72 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 28 + "True": 72 test-flag8673: - percentage: 73 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 27 + "True": 73 test-flag8674: - percentage: 74 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 26 + "True": 74 test-flag8675: - percentage: 75 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 25 + "True": 75 test-flag8676: - percentage: 76 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 24 + "True": 76 test-flag8677: - percentage: 77 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 23 + "True": 77 test-flag8678: - percentage: 78 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 22 + "True": 78 test-flag8679: - percentage: 79 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 21 + "True": 79 test-flag8680: - percentage: 80 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 20 + "True": 80 test-flag8681: - percentage: 81 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 19 + "True": 81 test-flag8682: - percentage: 82 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 18 + "True": 82 test-flag8683: - percentage: 83 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 17 + "True": 83 test-flag8684: - percentage: 84 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 16 + "True": 84 test-flag8685: - percentage: 85 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 15 + "True": 85 test-flag8686: - percentage: 86 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 14 + "True": 86 test-flag8687: - percentage: 87 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 13 + "True": 87 test-flag8688: - percentage: 88 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 12 + "True": 88 test-flag8689: - percentage: 89 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 11 + "True": 89 test-flag8690: - percentage: 90 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 10 + "True": 90 test-flag8691: - percentage: 91 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 9 + "True": 91 test-flag8692: - percentage: 92 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 8 + "True": 92 test-flag8693: - percentage: 93 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 7 + "True": 93 test-flag8694: - percentage: 94 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 6 + "True": 94 test-flag8695: - percentage: 95 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 5 + "True": 95 test-flag8696: - percentage: 96 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 4 + "True": 96 test-flag8697: - percentage: 97 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 3 + "True": 97 test-flag8698: - percentage: 98 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 2 + "True": 98 test-flag8699: - percentage: 99 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 1 + "True": 99 test-flag8700: - percentage: 0 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 100 + "True": 0 test-flag8701: - percentage: 1 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 99 + "True": 1 test-flag8702: - percentage: 2 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 98 + "True": 2 test-flag8703: - percentage: 3 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 97 + "True": 3 test-flag8704: - percentage: 4 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 96 + "True": 4 test-flag8705: - percentage: 5 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 95 + "True": 5 test-flag8706: - percentage: 6 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 94 + "True": 6 test-flag8707: - percentage: 7 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 93 + "True": 7 test-flag8708: - percentage: 8 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 92 + "True": 8 test-flag8709: - percentage: 9 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 91 + "True": 9 test-flag8710: - percentage: 10 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 90 + "True": 10 test-flag8711: - percentage: 11 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 89 + "True": 11 test-flag8712: - percentage: 12 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 88 + "True": 12 test-flag8713: - percentage: 13 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 87 + "True": 13 test-flag8714: - percentage: 14 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 86 + "True": 14 test-flag8715: - percentage: 15 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 85 + "True": 15 test-flag8716: - percentage: 16 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 84 + "True": 16 test-flag8717: - percentage: 17 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 83 + "True": 17 test-flag8718: - percentage: 18 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 82 + "True": 18 test-flag8719: - percentage: 19 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 81 + "True": 19 test-flag8720: - percentage: 20 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 80 + "True": 20 test-flag8721: - percentage: 21 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 79 + "True": 21 test-flag8722: - percentage: 22 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 78 + "True": 22 test-flag8723: - percentage: 23 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 77 + "True": 23 test-flag8724: - percentage: 24 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 76 + "True": 24 test-flag8725: - percentage: 25 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 75 + "True": 25 test-flag8726: - percentage: 26 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 74 + "True": 26 test-flag8727: - percentage: 27 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 73 + "True": 27 test-flag8728: - percentage: 28 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 72 + "True": 28 test-flag8729: - percentage: 29 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 71 + "True": 29 test-flag8730: - percentage: 30 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 70 + "True": 30 test-flag8731: - percentage: 31 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 69 + "True": 31 test-flag8732: - percentage: 32 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 68 + "True": 32 test-flag8733: - percentage: 33 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 67 + "True": 33 test-flag8734: - percentage: 34 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 66 + "True": 34 test-flag8735: - percentage: 35 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 65 + "True": 35 test-flag8736: - percentage: 36 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 64 + "True": 36 test-flag8737: - percentage: 37 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 63 + "True": 37 test-flag8738: - percentage: 38 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 62 + "True": 38 test-flag8739: - percentage: 39 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 61 + "True": 39 test-flag8740: - percentage: 40 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 60 + "True": 40 test-flag8741: - percentage: 41 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 59 + "True": 41 test-flag8742: - percentage: 42 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 58 + "True": 42 test-flag8743: - percentage: 43 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 57 + "True": 43 test-flag8744: - percentage: 44 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 56 + "True": 44 test-flag8745: - percentage: 45 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 55 + "True": 45 test-flag8746: - percentage: 46 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 54 + "True": 46 test-flag8747: - percentage: 47 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 53 + "True": 47 test-flag8748: - percentage: 48 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 52 + "True": 48 test-flag8749: - percentage: 49 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 51 + "True": 49 test-flag8750: - percentage: 50 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 50 + "True": 50 test-flag8751: - percentage: 51 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 49 + "True": 51 test-flag8752: - percentage: 52 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 48 + "True": 52 test-flag8753: - percentage: 53 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 47 + "True": 53 test-flag8754: - percentage: 54 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 46 + "True": 54 test-flag8755: - percentage: 55 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 45 + "True": 55 test-flag8756: - percentage: 56 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 44 + "True": 56 test-flag8757: - percentage: 57 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 43 + "True": 57 test-flag8758: - percentage: 58 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 42 + "True": 58 test-flag8759: - percentage: 59 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 41 + "True": 59 test-flag8760: - percentage: 60 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 40 + "True": 60 test-flag8761: - percentage: 61 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 39 + "True": 61 test-flag8762: - percentage: 62 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 38 + "True": 62 test-flag8763: - percentage: 63 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 37 + "True": 63 test-flag8764: - percentage: 64 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 36 + "True": 64 test-flag8765: - percentage: 65 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 35 + "True": 65 test-flag8766: - percentage: 66 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 34 + "True": 66 test-flag8767: - percentage: 67 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 33 + "True": 67 test-flag8768: - percentage: 68 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 32 + "True": 68 test-flag8769: - percentage: 69 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 31 + "True": 69 test-flag8770: - percentage: 70 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 30 + "True": 70 test-flag8771: - percentage: 71 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 29 + "True": 71 test-flag8772: - percentage: 72 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 28 + "True": 72 test-flag8773: - percentage: 73 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 27 + "True": 73 test-flag8774: - percentage: 74 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 26 + "True": 74 test-flag8775: - percentage: 75 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 25 + "True": 75 test-flag8776: - percentage: 76 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 24 + "True": 76 test-flag8777: - percentage: 77 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 23 + "True": 77 test-flag8778: - percentage: 78 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 22 + "True": 78 test-flag8779: - percentage: 79 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 21 + "True": 79 test-flag8780: - percentage: 80 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 20 + "True": 80 test-flag8781: - percentage: 81 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 19 + "True": 81 test-flag8782: - percentage: 82 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 18 + "True": 82 test-flag8783: - percentage: 83 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 17 + "True": 83 test-flag8784: - percentage: 84 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 16 + "True": 84 test-flag8785: - percentage: 85 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 15 + "True": 85 test-flag8786: - percentage: 86 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 14 + "True": 86 test-flag8787: - percentage: 87 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 13 + "True": 87 test-flag8788: - percentage: 88 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 12 + "True": 88 test-flag8789: - percentage: 89 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 11 + "True": 89 test-flag8790: - percentage: 90 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 10 + "True": 90 test-flag8791: - percentage: 91 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 9 + "True": 91 test-flag8792: - percentage: 92 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 8 + "True": 92 test-flag8793: - percentage: 93 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 7 + "True": 93 test-flag8794: - percentage: 94 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 6 + "True": 94 test-flag8795: - percentage: 95 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 5 + "True": 95 test-flag8796: - percentage: 96 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 4 + "True": 96 test-flag8797: - percentage: 97 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 3 + "True": 97 test-flag8798: - percentage: 98 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 2 + "True": 98 test-flag8799: - percentage: 99 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 1 + "True": 99 test-flag8800: - percentage: 0 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 100 + "True": 0 test-flag8801: - percentage: 1 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 99 + "True": 1 test-flag8802: - percentage: 2 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 98 + "True": 2 test-flag8803: - percentage: 3 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 97 + "True": 3 test-flag8804: - percentage: 4 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 96 + "True": 4 test-flag8805: - percentage: 5 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 95 + "True": 5 test-flag8806: - percentage: 6 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 94 + "True": 6 test-flag8807: - percentage: 7 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 93 + "True": 7 test-flag8808: - percentage: 8 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 92 + "True": 8 test-flag8809: - percentage: 9 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 91 + "True": 9 test-flag8810: - percentage: 10 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 90 + "True": 10 test-flag8811: - percentage: 11 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 89 + "True": 11 test-flag8812: - percentage: 12 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 88 + "True": 12 test-flag8813: - percentage: 13 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 87 + "True": 13 test-flag8814: - percentage: 14 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 86 + "True": 14 test-flag8815: - percentage: 15 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 85 + "True": 15 test-flag8816: - percentage: 16 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 84 + "True": 16 test-flag8817: - percentage: 17 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 83 + "True": 17 test-flag8818: - percentage: 18 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 82 + "True": 18 test-flag8819: - percentage: 19 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 81 + "True": 19 test-flag8820: - percentage: 20 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 80 + "True": 20 test-flag8821: - percentage: 21 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 79 + "True": 21 test-flag8822: - percentage: 22 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 78 + "True": 22 test-flag8823: - percentage: 23 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 77 + "True": 23 test-flag8824: - percentage: 24 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 76 + "True": 24 test-flag8825: - percentage: 25 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 75 + "True": 25 test-flag8826: - percentage: 26 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 74 + "True": 26 test-flag8827: - percentage: 27 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 73 + "True": 27 test-flag8828: - percentage: 28 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 72 + "True": 28 test-flag8829: - percentage: 29 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 71 + "True": 29 test-flag8830: - percentage: 30 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 70 + "True": 30 test-flag8831: - percentage: 31 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 69 + "True": 31 test-flag8832: - percentage: 32 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 68 + "True": 32 test-flag8833: - percentage: 33 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 67 + "True": 33 test-flag8834: - percentage: 34 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 66 + "True": 34 test-flag8835: - percentage: 35 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 65 + "True": 35 test-flag8836: - percentage: 36 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 64 + "True": 36 test-flag8837: - percentage: 37 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 63 + "True": 37 test-flag8838: - percentage: 38 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 62 + "True": 38 test-flag8839: - percentage: 39 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 61 + "True": 39 test-flag8840: - percentage: 40 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 60 + "True": 40 test-flag8841: - percentage: 41 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 59 + "True": 41 test-flag8842: - percentage: 42 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 58 + "True": 42 test-flag8843: - percentage: 43 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 57 + "True": 43 test-flag8844: - percentage: 44 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 56 + "True": 44 test-flag8845: - percentage: 45 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 55 + "True": 45 test-flag8846: - percentage: 46 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 54 + "True": 46 test-flag8847: - percentage: 47 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 53 + "True": 47 test-flag8848: - percentage: 48 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 52 + "True": 48 test-flag8849: - percentage: 49 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 51 + "True": 49 test-flag8850: - percentage: 50 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 50 + "True": 50 test-flag8851: - percentage: 51 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 49 + "True": 51 test-flag8852: - percentage: 52 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 48 + "True": 52 test-flag8853: - percentage: 53 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 47 + "True": 53 test-flag8854: - percentage: 54 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 46 + "True": 54 test-flag8855: - percentage: 55 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 45 + "True": 55 test-flag8856: - percentage: 56 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 44 + "True": 56 test-flag8857: - percentage: 57 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 43 + "True": 57 test-flag8858: - percentage: 58 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 42 + "True": 58 test-flag8859: - percentage: 59 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 41 + "True": 59 test-flag8860: - percentage: 60 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 40 + "True": 60 test-flag8861: - percentage: 61 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 39 + "True": 61 test-flag8862: - percentage: 62 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 38 + "True": 62 test-flag8863: - percentage: 63 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 37 + "True": 63 test-flag8864: - percentage: 64 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 36 + "True": 64 test-flag8865: - percentage: 65 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 35 + "True": 65 test-flag8866: - percentage: 66 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 34 + "True": 66 test-flag8867: - percentage: 67 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 33 + "True": 67 test-flag8868: - percentage: 68 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 32 + "True": 68 test-flag8869: - percentage: 69 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 31 + "True": 69 test-flag8870: - percentage: 70 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 30 + "True": 70 test-flag8871: - percentage: 71 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 29 + "True": 71 test-flag8872: - percentage: 72 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 28 + "True": 72 test-flag8873: - percentage: 73 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 27 + "True": 73 test-flag8874: - percentage: 74 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 26 + "True": 74 test-flag8875: - percentage: 75 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 25 + "True": 75 test-flag8876: - percentage: 76 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 24 + "True": 76 test-flag8877: - percentage: 77 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 23 + "True": 77 test-flag8878: - percentage: 78 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 22 + "True": 78 test-flag8879: - percentage: 79 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 21 + "True": 79 test-flag8880: - percentage: 80 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 20 + "True": 80 test-flag8881: - percentage: 81 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 19 + "True": 81 test-flag8882: - percentage: 82 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 18 + "True": 82 test-flag8883: - percentage: 83 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 17 + "True": 83 test-flag8884: - percentage: 84 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 16 + "True": 84 test-flag8885: - percentage: 85 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 15 + "True": 85 test-flag8886: - percentage: 86 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 14 + "True": 86 test-flag8887: - percentage: 87 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 13 + "True": 87 test-flag8888: - percentage: 88 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 12 + "True": 88 test-flag8889: - percentage: 89 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 11 + "True": 89 test-flag8890: - percentage: 90 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 10 + "True": 90 test-flag8891: - percentage: 91 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 9 + "True": 91 test-flag8892: - percentage: 92 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 8 + "True": 92 test-flag8893: - percentage: 93 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 7 + "True": 93 test-flag8894: - percentage: 94 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 6 + "True": 94 test-flag8895: - percentage: 95 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 5 + "True": 95 test-flag8896: - percentage: 96 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 4 + "True": 96 test-flag8897: - percentage: 97 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 3 + "True": 97 test-flag8898: - percentage: 98 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 2 + "True": 98 test-flag8899: - percentage: 99 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 1 + "True": 99 test-flag8900: - percentage: 0 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 100 + "True": 0 test-flag8901: - percentage: 1 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 99 + "True": 1 test-flag8902: - percentage: 2 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 98 + "True": 2 test-flag8903: - percentage: 3 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 97 + "True": 3 test-flag8904: - percentage: 4 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 96 + "True": 4 test-flag8905: - percentage: 5 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 95 + "True": 5 test-flag8906: - percentage: 6 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 94 + "True": 6 test-flag8907: - percentage: 7 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 93 + "True": 7 test-flag8908: - percentage: 8 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 92 + "True": 8 test-flag8909: - percentage: 9 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 91 + "True": 9 test-flag8910: - percentage: 10 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 90 + "True": 10 test-flag8911: - percentage: 11 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 89 + "True": 11 test-flag8912: - percentage: 12 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 88 + "True": 12 test-flag8913: - percentage: 13 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 87 + "True": 13 test-flag8914: - percentage: 14 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 86 + "True": 14 test-flag8915: - percentage: 15 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 85 + "True": 15 test-flag8916: - percentage: 16 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 84 + "True": 16 test-flag8917: - percentage: 17 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 83 + "True": 17 test-flag8918: - percentage: 18 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 82 + "True": 18 test-flag8919: - percentage: 19 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 81 + "True": 19 test-flag8920: - percentage: 20 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 80 + "True": 20 test-flag8921: - percentage: 21 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 79 + "True": 21 test-flag8922: - percentage: 22 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 78 + "True": 22 test-flag8923: - percentage: 23 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 77 + "True": 23 test-flag8924: - percentage: 24 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 76 + "True": 24 test-flag8925: - percentage: 25 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 75 + "True": 25 test-flag8926: - percentage: 26 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 74 + "True": 26 test-flag8927: - percentage: 27 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 73 + "True": 27 test-flag8928: - percentage: 28 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 72 + "True": 28 test-flag8929: - percentage: 29 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 71 + "True": 29 test-flag8930: - percentage: 30 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 70 + "True": 30 test-flag8931: - percentage: 31 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 69 + "True": 31 test-flag8932: - percentage: 32 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 68 + "True": 32 test-flag8933: - percentage: 33 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 67 + "True": 33 test-flag8934: - percentage: 34 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 66 + "True": 34 test-flag8935: - percentage: 35 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 65 + "True": 35 test-flag8936: - percentage: 36 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 64 + "True": 36 test-flag8937: - percentage: 37 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 63 + "True": 37 test-flag8938: - percentage: 38 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 62 + "True": 38 test-flag8939: - percentage: 39 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 61 + "True": 39 test-flag8940: - percentage: 40 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 60 + "True": 40 test-flag8941: - percentage: 41 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 59 + "True": 41 test-flag8942: - percentage: 42 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 58 + "True": 42 test-flag8943: - percentage: 43 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 57 + "True": 43 test-flag8944: - percentage: 44 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 56 + "True": 44 test-flag8945: - percentage: 45 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 55 + "True": 45 test-flag8946: - percentage: 46 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 54 + "True": 46 test-flag8947: - percentage: 47 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 53 + "True": 47 test-flag8948: - percentage: 48 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 52 + "True": 48 test-flag8949: - percentage: 49 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 51 + "True": 49 test-flag8950: - percentage: 50 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 50 + "True": 50 test-flag8951: - percentage: 51 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 49 + "True": 51 test-flag8952: - percentage: 52 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 48 + "True": 52 test-flag8953: - percentage: 53 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 47 + "True": 53 test-flag8954: - percentage: 54 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 46 + "True": 54 test-flag8955: - percentage: 55 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 45 + "True": 55 test-flag8956: - percentage: 56 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 44 + "True": 56 test-flag8957: - percentage: 57 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 43 + "True": 57 test-flag8958: - percentage: 58 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 42 + "True": 58 test-flag8959: - percentage: 59 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 41 + "True": 59 test-flag8960: - percentage: 60 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 40 + "True": 60 test-flag8961: - percentage: 61 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 39 + "True": 61 test-flag8962: - percentage: 62 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 38 + "True": 62 test-flag8963: - percentage: 63 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 37 + "True": 63 test-flag8964: - percentage: 64 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 36 + "True": 64 test-flag8965: - percentage: 65 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 35 + "True": 65 test-flag8966: - percentage: 66 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 34 + "True": 66 test-flag8967: - percentage: 67 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 33 + "True": 67 test-flag8968: - percentage: 68 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 32 + "True": 68 test-flag8969: - percentage: 69 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 31 + "True": 69 test-flag8970: - percentage: 70 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 30 + "True": 70 test-flag8971: - percentage: 71 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 29 + "True": 71 test-flag8972: - percentage: 72 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 28 + "True": 72 test-flag8973: - percentage: 73 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 27 + "True": 73 test-flag8974: - percentage: 74 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 26 + "True": 74 test-flag8975: - percentage: 75 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 25 + "True": 75 test-flag8976: - percentage: 76 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 24 + "True": 76 test-flag8977: - percentage: 77 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 23 + "True": 77 test-flag8978: - percentage: 78 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 22 + "True": 78 test-flag8979: - percentage: 79 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 21 + "True": 79 test-flag8980: - percentage: 80 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 20 + "True": 80 test-flag8981: - percentage: 81 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 19 + "True": 81 test-flag8982: - percentage: 82 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 18 + "True": 82 test-flag8983: - percentage: 83 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 17 + "True": 83 test-flag8984: - percentage: 84 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 16 + "True": 84 test-flag8985: - percentage: 85 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 15 + "True": 85 test-flag8986: - percentage: 86 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 14 + "True": 86 test-flag8987: - percentage: 87 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 13 + "True": 87 test-flag8988: - percentage: 88 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 12 + "True": 88 test-flag8989: - percentage: 89 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 11 + "True": 89 test-flag8990: - percentage: 90 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 10 + "True": 90 test-flag8991: - percentage: 91 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 9 + "True": 91 test-flag8992: - percentage: 92 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 8 + "True": 92 test-flag8993: - percentage: 93 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 7 + "True": 93 test-flag8994: - percentage: 94 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 6 + "True": 94 test-flag8995: - percentage: 95 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 5 + "True": 95 test-flag8996: - percentage: 96 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 4 + "True": 96 test-flag8997: - percentage: 97 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 3 + "True": 97 test-flag8998: - percentage: 98 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 2 + "True": 98 test-flag8999: - percentage: 99 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 1 + "True": 99 test-flag9000: - percentage: 0 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 100 + "True": 0 test-flag9001: - percentage: 1 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 99 + "True": 1 test-flag9002: - percentage: 2 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 98 + "True": 2 test-flag9003: - percentage: 3 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 97 + "True": 3 test-flag9004: - percentage: 4 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 96 + "True": 4 test-flag9005: - percentage: 5 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 95 + "True": 5 test-flag9006: - percentage: 6 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 94 + "True": 6 test-flag9007: - percentage: 7 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 93 + "True": 7 test-flag9008: - percentage: 8 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 92 + "True": 8 test-flag9009: - percentage: 9 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 91 + "True": 9 test-flag9010: - percentage: 10 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 90 + "True": 10 test-flag9011: - percentage: 11 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 89 + "True": 11 test-flag9012: - percentage: 12 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 88 + "True": 12 test-flag9013: - percentage: 13 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 87 + "True": 13 test-flag9014: - percentage: 14 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 86 + "True": 14 test-flag9015: - percentage: 15 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 85 + "True": 15 test-flag9016: - percentage: 16 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 84 + "True": 16 test-flag9017: - percentage: 17 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 83 + "True": 17 test-flag9018: - percentage: 18 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 82 + "True": 18 test-flag9019: - percentage: 19 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 81 + "True": 19 test-flag9020: - percentage: 20 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 80 + "True": 20 test-flag9021: - percentage: 21 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 79 + "True": 21 test-flag9022: - percentage: 22 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 78 + "True": 22 test-flag9023: - percentage: 23 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 77 + "True": 23 test-flag9024: - percentage: 24 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 76 + "True": 24 test-flag9025: - percentage: 25 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 75 + "True": 25 test-flag9026: - percentage: 26 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 74 + "True": 26 test-flag9027: - percentage: 27 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 73 + "True": 27 test-flag9028: - percentage: 28 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 72 + "True": 28 test-flag9029: - percentage: 29 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 71 + "True": 29 test-flag9030: - percentage: 30 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 70 + "True": 30 test-flag9031: - percentage: 31 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 69 + "True": 31 test-flag9032: - percentage: 32 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 68 + "True": 32 test-flag9033: - percentage: 33 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 67 + "True": 33 test-flag9034: - percentage: 34 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 66 + "True": 34 test-flag9035: - percentage: 35 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 65 + "True": 35 test-flag9036: - percentage: 36 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 64 + "True": 36 test-flag9037: - percentage: 37 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 63 + "True": 37 test-flag9038: - percentage: 38 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 62 + "True": 38 test-flag9039: - percentage: 39 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 61 + "True": 39 test-flag9040: - percentage: 40 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 60 + "True": 40 test-flag9041: - percentage: 41 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 59 + "True": 41 test-flag9042: - percentage: 42 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 58 + "True": 42 test-flag9043: - percentage: 43 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 57 + "True": 43 test-flag9044: - percentage: 44 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 56 + "True": 44 test-flag9045: - percentage: 45 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 55 + "True": 45 test-flag9046: - percentage: 46 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 54 + "True": 46 test-flag9047: - percentage: 47 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 53 + "True": 47 test-flag9048: - percentage: 48 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 52 + "True": 48 test-flag9049: - percentage: 49 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 51 + "True": 49 test-flag9050: - percentage: 50 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 50 + "True": 50 test-flag9051: - percentage: 51 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 49 + "True": 51 test-flag9052: - percentage: 52 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 48 + "True": 52 test-flag9053: - percentage: 53 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 47 + "True": 53 test-flag9054: - percentage: 54 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 46 + "True": 54 test-flag9055: - percentage: 55 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 45 + "True": 55 test-flag9056: - percentage: 56 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 44 + "True": 56 test-flag9057: - percentage: 57 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 43 + "True": 57 test-flag9058: - percentage: 58 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 42 + "True": 58 test-flag9059: - percentage: 59 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 41 + "True": 59 test-flag9060: - percentage: 60 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 40 + "True": 60 test-flag9061: - percentage: 61 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 39 + "True": 61 test-flag9062: - percentage: 62 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 38 + "True": 62 test-flag9063: - percentage: 63 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 37 + "True": 63 test-flag9064: - percentage: 64 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 36 + "True": 64 test-flag9065: - percentage: 65 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 35 + "True": 65 test-flag9066: - percentage: 66 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 34 + "True": 66 test-flag9067: - percentage: 67 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 33 + "True": 67 test-flag9068: - percentage: 68 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 32 + "True": 68 test-flag9069: - percentage: 69 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 31 + "True": 69 test-flag9070: - percentage: 70 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 30 + "True": 70 test-flag9071: - percentage: 71 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 29 + "True": 71 test-flag9072: - percentage: 72 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 28 + "True": 72 test-flag9073: - percentage: 73 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 27 + "True": 73 test-flag9074: - percentage: 74 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 26 + "True": 74 test-flag9075: - percentage: 75 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 25 + "True": 75 test-flag9076: - percentage: 76 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 24 + "True": 76 test-flag9077: - percentage: 77 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 23 + "True": 77 test-flag9078: - percentage: 78 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 22 + "True": 78 test-flag9079: - percentage: 79 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 21 + "True": 79 test-flag9080: - percentage: 80 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 20 + "True": 80 test-flag9081: - percentage: 81 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 19 + "True": 81 test-flag9082: - percentage: 82 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 18 + "True": 82 test-flag9083: - percentage: 83 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 17 + "True": 83 test-flag9084: - percentage: 84 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 16 + "True": 84 test-flag9085: - percentage: 85 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 15 + "True": 85 test-flag9086: - percentage: 86 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 14 + "True": 86 test-flag9087: - percentage: 87 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 13 + "True": 87 test-flag9088: - percentage: 88 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 12 + "True": 88 test-flag9089: - percentage: 89 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 11 + "True": 89 test-flag9090: - percentage: 90 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 10 + "True": 90 test-flag9091: - percentage: 91 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 9 + "True": 91 test-flag9092: - percentage: 92 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 8 + "True": 92 test-flag9093: - percentage: 93 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 7 + "True": 93 test-flag9094: - percentage: 94 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 6 + "True": 94 test-flag9095: - percentage: 95 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 5 + "True": 95 test-flag9096: - percentage: 96 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 4 + "True": 96 test-flag9097: - percentage: 97 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 3 + "True": 97 test-flag9098: - percentage: 98 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 2 + "True": 98 test-flag9099: - percentage: 99 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 1 + "True": 99 test-flag9100: - percentage: 0 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 100 + "True": 0 test-flag9101: - percentage: 1 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 99 + "True": 1 test-flag9102: - percentage: 2 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 98 + "True": 2 test-flag9103: - percentage: 3 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 97 + "True": 3 test-flag9104: - percentage: 4 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 96 + "True": 4 test-flag9105: - percentage: 5 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 95 + "True": 5 test-flag9106: - percentage: 6 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 94 + "True": 6 test-flag9107: - percentage: 7 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 93 + "True": 7 test-flag9108: - percentage: 8 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 92 + "True": 8 test-flag9109: - percentage: 9 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 91 + "True": 9 test-flag9110: - percentage: 10 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 90 + "True": 10 test-flag9111: - percentage: 11 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 89 + "True": 11 test-flag9112: - percentage: 12 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 88 + "True": 12 test-flag9113: - percentage: 13 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 87 + "True": 13 test-flag9114: - percentage: 14 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 86 + "True": 14 test-flag9115: - percentage: 15 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 85 + "True": 15 test-flag9116: - percentage: 16 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 84 + "True": 16 test-flag9117: - percentage: 17 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 83 + "True": 17 test-flag9118: - percentage: 18 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 82 + "True": 18 test-flag9119: - percentage: 19 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 81 + "True": 19 test-flag9120: - percentage: 20 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 80 + "True": 20 test-flag9121: - percentage: 21 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 79 + "True": 21 test-flag9122: - percentage: 22 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 78 + "True": 22 test-flag9123: - percentage: 23 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 77 + "True": 23 test-flag9124: - percentage: 24 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 76 + "True": 24 test-flag9125: - percentage: 25 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 75 + "True": 25 test-flag9126: - percentage: 26 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 74 + "True": 26 test-flag9127: - percentage: 27 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 73 + "True": 27 test-flag9128: - percentage: 28 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 72 + "True": 28 test-flag9129: - percentage: 29 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 71 + "True": 29 test-flag9130: - percentage: 30 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 70 + "True": 30 test-flag9131: - percentage: 31 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 69 + "True": 31 test-flag9132: - percentage: 32 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 68 + "True": 32 test-flag9133: - percentage: 33 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 67 + "True": 33 test-flag9134: - percentage: 34 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 66 + "True": 34 test-flag9135: - percentage: 35 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 65 + "True": 35 test-flag9136: - percentage: 36 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 64 + "True": 36 test-flag9137: - percentage: 37 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 63 + "True": 37 test-flag9138: - percentage: 38 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 62 + "True": 38 test-flag9139: - percentage: 39 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 61 + "True": 39 test-flag9140: - percentage: 40 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 60 + "True": 40 test-flag9141: - percentage: 41 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 59 + "True": 41 test-flag9142: - percentage: 42 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 58 + "True": 42 test-flag9143: - percentage: 43 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 57 + "True": 43 test-flag9144: - percentage: 44 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 56 + "True": 44 test-flag9145: - percentage: 45 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 55 + "True": 45 test-flag9146: - percentage: 46 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 54 + "True": 46 test-flag9147: - percentage: 47 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 53 + "True": 47 test-flag9148: - percentage: 48 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 52 + "True": 48 test-flag9149: - percentage: 49 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 51 + "True": 49 test-flag9150: - percentage: 50 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 50 + "True": 50 test-flag9151: - percentage: 51 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 49 + "True": 51 test-flag9152: - percentage: 52 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 48 + "True": 52 test-flag9153: - percentage: 53 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 47 + "True": 53 test-flag9154: - percentage: 54 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 46 + "True": 54 test-flag9155: - percentage: 55 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 45 + "True": 55 test-flag9156: - percentage: 56 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 44 + "True": 56 test-flag9157: - percentage: 57 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 43 + "True": 57 test-flag9158: - percentage: 58 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 42 + "True": 58 test-flag9159: - percentage: 59 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 41 + "True": 59 test-flag9160: - percentage: 60 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 40 + "True": 60 test-flag9161: - percentage: 61 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 39 + "True": 61 test-flag9162: - percentage: 62 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 38 + "True": 62 test-flag9163: - percentage: 63 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 37 + "True": 63 test-flag9164: - percentage: 64 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 36 + "True": 64 test-flag9165: - percentage: 65 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 35 + "True": 65 test-flag9166: - percentage: 66 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 34 + "True": 66 test-flag9167: - percentage: 67 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 33 + "True": 67 test-flag9168: - percentage: 68 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 32 + "True": 68 test-flag9169: - percentage: 69 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 31 + "True": 69 test-flag9170: - percentage: 70 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 30 + "True": 70 test-flag9171: - percentage: 71 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 29 + "True": 71 test-flag9172: - percentage: 72 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 28 + "True": 72 test-flag9173: - percentage: 73 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 27 + "True": 73 test-flag9174: - percentage: 74 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 26 + "True": 74 test-flag9175: - percentage: 75 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 25 + "True": 75 test-flag9176: - percentage: 76 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 24 + "True": 76 test-flag9177: - percentage: 77 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 23 + "True": 77 test-flag9178: - percentage: 78 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 22 + "True": 78 test-flag9179: - percentage: 79 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 21 + "True": 79 test-flag9180: - percentage: 80 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 20 + "True": 80 test-flag9181: - percentage: 81 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 19 + "True": 81 test-flag9182: - percentage: 82 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 18 + "True": 82 test-flag9183: - percentage: 83 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 17 + "True": 83 test-flag9184: - percentage: 84 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 16 + "True": 84 test-flag9185: - percentage: 85 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 15 + "True": 85 test-flag9186: - percentage: 86 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 14 + "True": 86 test-flag9187: - percentage: 87 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 13 + "True": 87 test-flag9188: - percentage: 88 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 12 + "True": 88 test-flag9189: - percentage: 89 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 11 + "True": 89 test-flag9190: - percentage: 90 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 10 + "True": 90 test-flag9191: - percentage: 91 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 9 + "True": 91 test-flag9192: - percentage: 92 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 8 + "True": 92 test-flag9193: - percentage: 93 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 7 + "True": 93 test-flag9194: - percentage: 94 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 6 + "True": 94 test-flag9195: - percentage: 95 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 5 + "True": 95 test-flag9196: - percentage: 96 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 4 + "True": 96 test-flag9197: - percentage: 97 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 3 + "True": 97 test-flag9198: - percentage: 98 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 2 + "True": 98 test-flag9199: - percentage: 99 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 1 + "True": 99 test-flag9200: - percentage: 0 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 100 + "True": 0 test-flag9201: - percentage: 1 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 99 + "True": 1 test-flag9202: - percentage: 2 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 98 + "True": 2 test-flag9203: - percentage: 3 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 97 + "True": 3 test-flag9204: - percentage: 4 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 96 + "True": 4 test-flag9205: - percentage: 5 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 95 + "True": 5 test-flag9206: - percentage: 6 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 94 + "True": 6 test-flag9207: - percentage: 7 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 93 + "True": 7 test-flag9208: - percentage: 8 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 92 + "True": 8 test-flag9209: - percentage: 9 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 91 + "True": 9 test-flag9210: - percentage: 10 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 90 + "True": 10 test-flag9211: - percentage: 11 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 89 + "True": 11 test-flag9212: - percentage: 12 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 88 + "True": 12 test-flag9213: - percentage: 13 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 87 + "True": 13 test-flag9214: - percentage: 14 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 86 + "True": 14 test-flag9215: - percentage: 15 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 85 + "True": 15 test-flag9216: - percentage: 16 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 84 + "True": 16 test-flag9217: - percentage: 17 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 83 + "True": 17 test-flag9218: - percentage: 18 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 82 + "True": 18 test-flag9219: - percentage: 19 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 81 + "True": 19 test-flag9220: - percentage: 20 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 80 + "True": 20 test-flag9221: - percentage: 21 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 79 + "True": 21 test-flag9222: - percentage: 22 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 78 + "True": 22 test-flag9223: - percentage: 23 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 77 + "True": 23 test-flag9224: - percentage: 24 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 76 + "True": 24 test-flag9225: - percentage: 25 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 75 + "True": 25 test-flag9226: - percentage: 26 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 74 + "True": 26 test-flag9227: - percentage: 27 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 73 + "True": 27 test-flag9228: - percentage: 28 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 72 + "True": 28 test-flag9229: - percentage: 29 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 71 + "True": 29 test-flag9230: - percentage: 30 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 70 + "True": 30 test-flag9231: - percentage: 31 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 69 + "True": 31 test-flag9232: - percentage: 32 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 68 + "True": 32 test-flag9233: - percentage: 33 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 67 + "True": 33 test-flag9234: - percentage: 34 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 66 + "True": 34 test-flag9235: - percentage: 35 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 65 + "True": 35 test-flag9236: - percentage: 36 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 64 + "True": 36 test-flag9237: - percentage: 37 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 63 + "True": 37 test-flag9238: - percentage: 38 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 62 + "True": 38 test-flag9239: - percentage: 39 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 61 + "True": 39 test-flag9240: - percentage: 40 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 60 + "True": 40 test-flag9241: - percentage: 41 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 59 + "True": 41 test-flag9242: - percentage: 42 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 58 + "True": 42 test-flag9243: - percentage: 43 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 57 + "True": 43 test-flag9244: - percentage: 44 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 56 + "True": 44 test-flag9245: - percentage: 45 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 55 + "True": 45 test-flag9246: - percentage: 46 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 54 + "True": 46 test-flag9247: - percentage: 47 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 53 + "True": 47 test-flag9248: - percentage: 48 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 52 + "True": 48 test-flag9249: - percentage: 49 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 51 + "True": 49 test-flag9250: - percentage: 50 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 50 + "True": 50 test-flag9251: - percentage: 51 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 49 + "True": 51 test-flag9252: - percentage: 52 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 48 + "True": 52 test-flag9253: - percentage: 53 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 47 + "True": 53 test-flag9254: - percentage: 54 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 46 + "True": 54 test-flag9255: - percentage: 55 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 45 + "True": 55 test-flag9256: - percentage: 56 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 44 + "True": 56 test-flag9257: - percentage: 57 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 43 + "True": 57 test-flag9258: - percentage: 58 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 42 + "True": 58 test-flag9259: - percentage: 59 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 41 + "True": 59 test-flag9260: - percentage: 60 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 40 + "True": 60 test-flag9261: - percentage: 61 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 39 + "True": 61 test-flag9262: - percentage: 62 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 38 + "True": 62 test-flag9263: - percentage: 63 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 37 + "True": 63 test-flag9264: - percentage: 64 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 36 + "True": 64 test-flag9265: - percentage: 65 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 35 + "True": 65 test-flag9266: - percentage: 66 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 34 + "True": 66 test-flag9267: - percentage: 67 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 33 + "True": 67 test-flag9268: - percentage: 68 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 32 + "True": 68 test-flag9269: - percentage: 69 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 31 + "True": 69 test-flag9270: - percentage: 70 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 30 + "True": 70 test-flag9271: - percentage: 71 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 29 + "True": 71 test-flag9272: - percentage: 72 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 28 + "True": 72 test-flag9273: - percentage: 73 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 27 + "True": 73 test-flag9274: - percentage: 74 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 26 + "True": 74 test-flag9275: - percentage: 75 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 25 + "True": 75 test-flag9276: - percentage: 76 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 24 + "True": 76 test-flag9277: - percentage: 77 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 23 + "True": 77 test-flag9278: - percentage: 78 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 22 + "True": 78 test-flag9279: - percentage: 79 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 21 + "True": 79 test-flag9280: - percentage: 80 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 20 + "True": 80 test-flag9281: - percentage: 81 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 19 + "True": 81 test-flag9282: - percentage: 82 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 18 + "True": 82 test-flag9283: - percentage: 83 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 17 + "True": 83 test-flag9284: - percentage: 84 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 16 + "True": 84 test-flag9285: - percentage: 85 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 15 + "True": 85 test-flag9286: - percentage: 86 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 14 + "True": 86 test-flag9287: - percentage: 87 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 13 + "True": 87 test-flag9288: - percentage: 88 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 12 + "True": 88 test-flag9289: - percentage: 89 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 11 + "True": 89 test-flag9290: - percentage: 90 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 10 + "True": 90 test-flag9291: - percentage: 91 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 9 + "True": 91 test-flag9292: - percentage: 92 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 8 + "True": 92 test-flag9293: - percentage: 93 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 7 + "True": 93 test-flag9294: - percentage: 94 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 6 + "True": 94 test-flag9295: - percentage: 95 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 5 + "True": 95 test-flag9296: - percentage: 96 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 4 + "True": 96 test-flag9297: - percentage: 97 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 3 + "True": 97 test-flag9298: - percentage: 98 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 2 + "True": 98 test-flag9299: - percentage: 99 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 1 + "True": 99 test-flag9300: - percentage: 0 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 100 + "True": 0 test-flag9301: - percentage: 1 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 99 + "True": 1 test-flag9302: - percentage: 2 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 98 + "True": 2 test-flag9303: - percentage: 3 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 97 + "True": 3 test-flag9304: - percentage: 4 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 96 + "True": 4 test-flag9305: - percentage: 5 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 95 + "True": 5 test-flag9306: - percentage: 6 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 94 + "True": 6 test-flag9307: - percentage: 7 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 93 + "True": 7 test-flag9308: - percentage: 8 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 92 + "True": 8 test-flag9309: - percentage: 9 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 91 + "True": 9 test-flag9310: - percentage: 10 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 90 + "True": 10 test-flag9311: - percentage: 11 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 89 + "True": 11 test-flag9312: - percentage: 12 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 88 + "True": 12 test-flag9313: - percentage: 13 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 87 + "True": 13 test-flag9314: - percentage: 14 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 86 + "True": 14 test-flag9315: - percentage: 15 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 85 + "True": 15 test-flag9316: - percentage: 16 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 84 + "True": 16 test-flag9317: - percentage: 17 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 83 + "True": 17 test-flag9318: - percentage: 18 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 82 + "True": 18 test-flag9319: - percentage: 19 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 81 + "True": 19 test-flag9320: - percentage: 20 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 80 + "True": 20 test-flag9321: - percentage: 21 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 79 + "True": 21 test-flag9322: - percentage: 22 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 78 + "True": 22 test-flag9323: - percentage: 23 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 77 + "True": 23 test-flag9324: - percentage: 24 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 76 + "True": 24 test-flag9325: - percentage: 25 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 75 + "True": 25 test-flag9326: - percentage: 26 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 74 + "True": 26 test-flag9327: - percentage: 27 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 73 + "True": 27 test-flag9328: - percentage: 28 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 72 + "True": 28 test-flag9329: - percentage: 29 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 71 + "True": 29 test-flag9330: - percentage: 30 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 70 + "True": 30 test-flag9331: - percentage: 31 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 69 + "True": 31 test-flag9332: - percentage: 32 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 68 + "True": 32 test-flag9333: - percentage: 33 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 67 + "True": 33 test-flag9334: - percentage: 34 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 66 + "True": 34 test-flag9335: - percentage: 35 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 65 + "True": 35 test-flag9336: - percentage: 36 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 64 + "True": 36 test-flag9337: - percentage: 37 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 63 + "True": 37 test-flag9338: - percentage: 38 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 62 + "True": 38 test-flag9339: - percentage: 39 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 61 + "True": 39 test-flag9340: - percentage: 40 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 60 + "True": 40 test-flag9341: - percentage: 41 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 59 + "True": 41 test-flag9342: - percentage: 42 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 58 + "True": 42 test-flag9343: - percentage: 43 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 57 + "True": 43 test-flag9344: - percentage: 44 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 56 + "True": 44 test-flag9345: - percentage: 45 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 55 + "True": 45 test-flag9346: - percentage: 46 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 54 + "True": 46 test-flag9347: - percentage: 47 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 53 + "True": 47 test-flag9348: - percentage: 48 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 52 + "True": 48 test-flag9349: - percentage: 49 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 51 + "True": 49 test-flag9350: - percentage: 50 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 50 + "True": 50 test-flag9351: - percentage: 51 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 49 + "True": 51 test-flag9352: - percentage: 52 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 48 + "True": 52 test-flag9353: - percentage: 53 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 47 + "True": 53 test-flag9354: - percentage: 54 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 46 + "True": 54 test-flag9355: - percentage: 55 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 45 + "True": 55 test-flag9356: - percentage: 56 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 44 + "True": 56 test-flag9357: - percentage: 57 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 43 + "True": 57 test-flag9358: - percentage: 58 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 42 + "True": 58 test-flag9359: - percentage: 59 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 41 + "True": 59 test-flag9360: - percentage: 60 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 40 + "True": 60 test-flag9361: - percentage: 61 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 39 + "True": 61 test-flag9362: - percentage: 62 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 38 + "True": 62 test-flag9363: - percentage: 63 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 37 + "True": 63 test-flag9364: - percentage: 64 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 36 + "True": 64 test-flag9365: - percentage: 65 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 35 + "True": 65 test-flag9366: - percentage: 66 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 34 + "True": 66 test-flag9367: - percentage: 67 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 33 + "True": 67 test-flag9368: - percentage: 68 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 32 + "True": 68 test-flag9369: - percentage: 69 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 31 + "True": 69 test-flag9370: - percentage: 70 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 30 + "True": 70 test-flag9371: - percentage: 71 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 29 + "True": 71 test-flag9372: - percentage: 72 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 28 + "True": 72 test-flag9373: - percentage: 73 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 27 + "True": 73 test-flag9374: - percentage: 74 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 26 + "True": 74 test-flag9375: - percentage: 75 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 25 + "True": 75 test-flag9376: - percentage: 76 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 24 + "True": 76 test-flag9377: - percentage: 77 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 23 + "True": 77 test-flag9378: - percentage: 78 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 22 + "True": 78 test-flag9379: - percentage: 79 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 21 + "True": 79 test-flag9380: - percentage: 80 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 20 + "True": 80 test-flag9381: - percentage: 81 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 19 + "True": 81 test-flag9382: - percentage: 82 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 18 + "True": 82 test-flag9383: - percentage: 83 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 17 + "True": 83 test-flag9384: - percentage: 84 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 16 + "True": 84 test-flag9385: - percentage: 85 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 15 + "True": 85 test-flag9386: - percentage: 86 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 14 + "True": 86 test-flag9387: - percentage: 87 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 13 + "True": 87 test-flag9388: - percentage: 88 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 12 + "True": 88 test-flag9389: - percentage: 89 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 11 + "True": 89 test-flag9390: - percentage: 90 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 10 + "True": 90 test-flag9391: - percentage: 91 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 9 + "True": 91 test-flag9392: - percentage: 92 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 8 + "True": 92 test-flag9393: - percentage: 93 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 7 + "True": 93 test-flag9394: - percentage: 94 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 6 + "True": 94 test-flag9395: - percentage: 95 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 5 + "True": 95 test-flag9396: - percentage: 96 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 4 + "True": 96 test-flag9397: - percentage: 97 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 3 + "True": 97 test-flag9398: - percentage: 98 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 2 + "True": 98 test-flag9399: - percentage: 99 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 1 + "True": 99 test-flag9400: - percentage: 0 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 100 + "True": 0 test-flag9401: - percentage: 1 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 99 + "True": 1 test-flag9402: - percentage: 2 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 98 + "True": 2 test-flag9403: - percentage: 3 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 97 + "True": 3 test-flag9404: - percentage: 4 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 96 + "True": 4 test-flag9405: - percentage: 5 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 95 + "True": 5 test-flag9406: - percentage: 6 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 94 + "True": 6 test-flag9407: - percentage: 7 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 93 + "True": 7 test-flag9408: - percentage: 8 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 92 + "True": 8 test-flag9409: - percentage: 9 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 91 + "True": 9 test-flag9410: - percentage: 10 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 90 + "True": 10 test-flag9411: - percentage: 11 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 89 + "True": 11 test-flag9412: - percentage: 12 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 88 + "True": 12 test-flag9413: - percentage: 13 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 87 + "True": 13 test-flag9414: - percentage: 14 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 86 + "True": 14 test-flag9415: - percentage: 15 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 85 + "True": 15 test-flag9416: - percentage: 16 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 84 + "True": 16 test-flag9417: - percentage: 17 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 83 + "True": 17 test-flag9418: - percentage: 18 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 82 + "True": 18 test-flag9419: - percentage: 19 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 81 + "True": 19 test-flag9420: - percentage: 20 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 80 + "True": 20 test-flag9421: - percentage: 21 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 79 + "True": 21 test-flag9422: - percentage: 22 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 78 + "True": 22 test-flag9423: - percentage: 23 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 77 + "True": 23 test-flag9424: - percentage: 24 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 76 + "True": 24 test-flag9425: - percentage: 25 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 75 + "True": 25 test-flag9426: - percentage: 26 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 74 + "True": 26 test-flag9427: - percentage: 27 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 73 + "True": 27 test-flag9428: - percentage: 28 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 72 + "True": 28 test-flag9429: - percentage: 29 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 71 + "True": 29 test-flag9430: - percentage: 30 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 70 + "True": 30 test-flag9431: - percentage: 31 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 69 + "True": 31 test-flag9432: - percentage: 32 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 68 + "True": 32 test-flag9433: - percentage: 33 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 67 + "True": 33 test-flag9434: - percentage: 34 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 66 + "True": 34 test-flag9435: - percentage: 35 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 65 + "True": 35 test-flag9436: - percentage: 36 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 64 + "True": 36 test-flag9437: - percentage: 37 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 63 + "True": 37 test-flag9438: - percentage: 38 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 62 + "True": 38 test-flag9439: - percentage: 39 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 61 + "True": 39 test-flag9440: - percentage: 40 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 60 + "True": 40 test-flag9441: - percentage: 41 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 59 + "True": 41 test-flag9442: - percentage: 42 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 58 + "True": 42 test-flag9443: - percentage: 43 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 57 + "True": 43 test-flag9444: - percentage: 44 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 56 + "True": 44 test-flag9445: - percentage: 45 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 55 + "True": 45 test-flag9446: - percentage: 46 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 54 + "True": 46 test-flag9447: - percentage: 47 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 53 + "True": 47 test-flag9448: - percentage: 48 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 52 + "True": 48 test-flag9449: - percentage: 49 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 51 + "True": 49 test-flag9450: - percentage: 50 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 50 + "True": 50 test-flag9451: - percentage: 51 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 49 + "True": 51 test-flag9452: - percentage: 52 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 48 + "True": 52 test-flag9453: - percentage: 53 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 47 + "True": 53 test-flag9454: - percentage: 54 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 46 + "True": 54 test-flag9455: - percentage: 55 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 45 + "True": 55 test-flag9456: - percentage: 56 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 44 + "True": 56 test-flag9457: - percentage: 57 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 43 + "True": 57 test-flag9458: - percentage: 58 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 42 + "True": 58 test-flag9459: - percentage: 59 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 41 + "True": 59 test-flag9460: - percentage: 60 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 40 + "True": 60 test-flag9461: - percentage: 61 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 39 + "True": 61 test-flag9462: - percentage: 62 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 38 + "True": 62 test-flag9463: - percentage: 63 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 37 + "True": 63 test-flag9464: - percentage: 64 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 36 + "True": 64 test-flag9465: - percentage: 65 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 35 + "True": 65 test-flag9466: - percentage: 66 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 34 + "True": 66 test-flag9467: - percentage: 67 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 33 + "True": 67 test-flag9468: - percentage: 68 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 32 + "True": 68 test-flag9469: - percentage: 69 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 31 + "True": 69 test-flag9470: - percentage: 70 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 30 + "True": 70 test-flag9471: - percentage: 71 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 29 + "True": 71 test-flag9472: - percentage: 72 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 28 + "True": 72 test-flag9473: - percentage: 73 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 27 + "True": 73 test-flag9474: - percentage: 74 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 26 + "True": 74 test-flag9475: - percentage: 75 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 25 + "True": 75 test-flag9476: - percentage: 76 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 24 + "True": 76 test-flag9477: - percentage: 77 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 23 + "True": 77 test-flag9478: - percentage: 78 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 22 + "True": 78 test-flag9479: - percentage: 79 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 21 + "True": 79 test-flag9480: - percentage: 80 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 20 + "True": 80 test-flag9481: - percentage: 81 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 19 + "True": 81 test-flag9482: - percentage: 82 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 18 + "True": 82 test-flag9483: - percentage: 83 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 17 + "True": 83 test-flag9484: - percentage: 84 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 16 + "True": 84 test-flag9485: - percentage: 85 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 15 + "True": 85 test-flag9486: - percentage: 86 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 14 + "True": 86 test-flag9487: - percentage: 87 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 13 + "True": 87 test-flag9488: - percentage: 88 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 12 + "True": 88 test-flag9489: - percentage: 89 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 11 + "True": 89 test-flag9490: - percentage: 90 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 10 + "True": 90 test-flag9491: - percentage: 91 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 9 + "True": 91 test-flag9492: - percentage: 92 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 8 + "True": 92 test-flag9493: - percentage: 93 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 7 + "True": 93 test-flag9494: - percentage: 94 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 6 + "True": 94 test-flag9495: - percentage: 95 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 5 + "True": 95 test-flag9496: - percentage: 96 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 4 + "True": 96 test-flag9497: - percentage: 97 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 3 + "True": 97 test-flag9498: - percentage: 98 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 2 + "True": 98 test-flag9499: - percentage: 99 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 1 + "True": 99 test-flag9500: - percentage: 0 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 100 + "True": 0 test-flag9501: - percentage: 1 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 99 + "True": 1 test-flag9502: - percentage: 2 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 98 + "True": 2 test-flag9503: - percentage: 3 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 97 + "True": 3 test-flag9504: - percentage: 4 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 96 + "True": 4 test-flag9505: - percentage: 5 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 95 + "True": 5 test-flag9506: - percentage: 6 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 94 + "True": 6 test-flag9507: - percentage: 7 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 93 + "True": 7 test-flag9508: - percentage: 8 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 92 + "True": 8 test-flag9509: - percentage: 9 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 91 + "True": 9 test-flag9510: - percentage: 10 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 90 + "True": 10 test-flag9511: - percentage: 11 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 89 + "True": 11 test-flag9512: - percentage: 12 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 88 + "True": 12 test-flag9513: - percentage: 13 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 87 + "True": 13 test-flag9514: - percentage: 14 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 86 + "True": 14 test-flag9515: - percentage: 15 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 85 + "True": 15 test-flag9516: - percentage: 16 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 84 + "True": 16 test-flag9517: - percentage: 17 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 83 + "True": 17 test-flag9518: - percentage: 18 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 82 + "True": 18 test-flag9519: - percentage: 19 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 81 + "True": 19 test-flag9520: - percentage: 20 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 80 + "True": 20 test-flag9521: - percentage: 21 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 79 + "True": 21 test-flag9522: - percentage: 22 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 78 + "True": 22 test-flag9523: - percentage: 23 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 77 + "True": 23 test-flag9524: - percentage: 24 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 76 + "True": 24 test-flag9525: - percentage: 25 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 75 + "True": 25 test-flag9526: - percentage: 26 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 74 + "True": 26 test-flag9527: - percentage: 27 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 73 + "True": 27 test-flag9528: - percentage: 28 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 72 + "True": 28 test-flag9529: - percentage: 29 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 71 + "True": 29 test-flag9530: - percentage: 30 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 70 + "True": 30 test-flag9531: - percentage: 31 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 69 + "True": 31 test-flag9532: - percentage: 32 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 68 + "True": 32 test-flag9533: - percentage: 33 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 67 + "True": 33 test-flag9534: - percentage: 34 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 66 + "True": 34 test-flag9535: - percentage: 35 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 65 + "True": 35 test-flag9536: - percentage: 36 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 64 + "True": 36 test-flag9537: - percentage: 37 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 63 + "True": 37 test-flag9538: - percentage: 38 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 62 + "True": 38 test-flag9539: - percentage: 39 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 61 + "True": 39 test-flag9540: - percentage: 40 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 60 + "True": 40 test-flag9541: - percentage: 41 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 59 + "True": 41 test-flag9542: - percentage: 42 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 58 + "True": 42 test-flag9543: - percentage: 43 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 57 + "True": 43 test-flag9544: - percentage: 44 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 56 + "True": 44 test-flag9545: - percentage: 45 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 55 + "True": 45 test-flag9546: - percentage: 46 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 54 + "True": 46 test-flag9547: - percentage: 47 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 53 + "True": 47 test-flag9548: - percentage: 48 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 52 + "True": 48 test-flag9549: - percentage: 49 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 51 + "True": 49 test-flag9550: - percentage: 50 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 50 + "True": 50 test-flag9551: - percentage: 51 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 49 + "True": 51 test-flag9552: - percentage: 52 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 48 + "True": 52 test-flag9553: - percentage: 53 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 47 + "True": 53 test-flag9554: - percentage: 54 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 46 + "True": 54 test-flag9555: - percentage: 55 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 45 + "True": 55 test-flag9556: - percentage: 56 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 44 + "True": 56 test-flag9557: - percentage: 57 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 43 + "True": 57 test-flag9558: - percentage: 58 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 42 + "True": 58 test-flag9559: - percentage: 59 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 41 + "True": 59 test-flag9560: - percentage: 60 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 40 + "True": 60 test-flag9561: - percentage: 61 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 39 + "True": 61 test-flag9562: - percentage: 62 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 38 + "True": 62 test-flag9563: - percentage: 63 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 37 + "True": 63 test-flag9564: - percentage: 64 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 36 + "True": 64 test-flag9565: - percentage: 65 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 35 + "True": 65 test-flag9566: - percentage: 66 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 34 + "True": 66 test-flag9567: - percentage: 67 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 33 + "True": 67 test-flag9568: - percentage: 68 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 32 + "True": 68 test-flag9569: - percentage: 69 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 31 + "True": 69 test-flag9570: - percentage: 70 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 30 + "True": 70 test-flag9571: - percentage: 71 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 29 + "True": 71 test-flag9572: - percentage: 72 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 28 + "True": 72 test-flag9573: - percentage: 73 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 27 + "True": 73 test-flag9574: - percentage: 74 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 26 + "True": 74 test-flag9575: - percentage: 75 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 25 + "True": 75 test-flag9576: - percentage: 76 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 24 + "True": 76 test-flag9577: - percentage: 77 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 23 + "True": 77 test-flag9578: - percentage: 78 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 22 + "True": 78 test-flag9579: - percentage: 79 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 21 + "True": 79 test-flag9580: - percentage: 80 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 20 + "True": 80 test-flag9581: - percentage: 81 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 19 + "True": 81 test-flag9582: - percentage: 82 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 18 + "True": 82 test-flag9583: - percentage: 83 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 17 + "True": 83 test-flag9584: - percentage: 84 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 16 + "True": 84 test-flag9585: - percentage: 85 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 15 + "True": 85 test-flag9586: - percentage: 86 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 14 + "True": 86 test-flag9587: - percentage: 87 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 13 + "True": 87 test-flag9588: - percentage: 88 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 12 + "True": 88 test-flag9589: - percentage: 89 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 11 + "True": 89 test-flag9590: - percentage: 90 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 10 + "True": 90 test-flag9591: - percentage: 91 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 9 + "True": 91 test-flag9592: - percentage: 92 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 8 + "True": 92 test-flag9593: - percentage: 93 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 7 + "True": 93 test-flag9594: - percentage: 94 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 6 + "True": 94 test-flag9595: - percentage: 95 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 5 + "True": 95 test-flag9596: - percentage: 96 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 4 + "True": 96 test-flag9597: - percentage: 97 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 3 + "True": 97 test-flag9598: - percentage: 98 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 2 + "True": 98 test-flag9599: - percentage: 99 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 1 + "True": 99 test-flag9600: - percentage: 0 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 100 + "True": 0 test-flag9601: - percentage: 1 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 99 + "True": 1 test-flag9602: - percentage: 2 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 98 + "True": 2 test-flag9603: - percentage: 3 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 97 + "True": 3 test-flag9604: - percentage: 4 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 96 + "True": 4 test-flag9605: - percentage: 5 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 95 + "True": 5 test-flag9606: - percentage: 6 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 94 + "True": 6 test-flag9607: - percentage: 7 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 93 + "True": 7 test-flag9608: - percentage: 8 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 92 + "True": 8 test-flag9609: - percentage: 9 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 91 + "True": 9 test-flag9610: - percentage: 10 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 90 + "True": 10 test-flag9611: - percentage: 11 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 89 + "True": 11 test-flag9612: - percentage: 12 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 88 + "True": 12 test-flag9613: - percentage: 13 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 87 + "True": 13 test-flag9614: - percentage: 14 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 86 + "True": 14 test-flag9615: - percentage: 15 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 85 + "True": 15 test-flag9616: - percentage: 16 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 84 + "True": 16 test-flag9617: - percentage: 17 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 83 + "True": 17 test-flag9618: - percentage: 18 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 82 + "True": 18 test-flag9619: - percentage: 19 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 81 + "True": 19 test-flag9620: - percentage: 20 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 80 + "True": 20 test-flag9621: - percentage: 21 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 79 + "True": 21 test-flag9622: - percentage: 22 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 78 + "True": 22 test-flag9623: - percentage: 23 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 77 + "True": 23 test-flag9624: - percentage: 24 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 76 + "True": 24 test-flag9625: - percentage: 25 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 75 + "True": 25 test-flag9626: - percentage: 26 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 74 + "True": 26 test-flag9627: - percentage: 27 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 73 + "True": 27 test-flag9628: - percentage: 28 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 72 + "True": 28 test-flag9629: - percentage: 29 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 71 + "True": 29 test-flag9630: - percentage: 30 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 70 + "True": 30 test-flag9631: - percentage: 31 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 69 + "True": 31 test-flag9632: - percentage: 32 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 68 + "True": 32 test-flag9633: - percentage: 33 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 67 + "True": 33 test-flag9634: - percentage: 34 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 66 + "True": 34 test-flag9635: - percentage: 35 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 65 + "True": 35 test-flag9636: - percentage: 36 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 64 + "True": 36 test-flag9637: - percentage: 37 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 63 + "True": 37 test-flag9638: - percentage: 38 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 62 + "True": 38 test-flag9639: - percentage: 39 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 61 + "True": 39 test-flag9640: - percentage: 40 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 60 + "True": 40 test-flag9641: - percentage: 41 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 59 + "True": 41 test-flag9642: - percentage: 42 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 58 + "True": 42 test-flag9643: - percentage: 43 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 57 + "True": 43 test-flag9644: - percentage: 44 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 56 + "True": 44 test-flag9645: - percentage: 45 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 55 + "True": 45 test-flag9646: - percentage: 46 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 54 + "True": 46 test-flag9647: - percentage: 47 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 53 + "True": 47 test-flag9648: - percentage: 48 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 52 + "True": 48 test-flag9649: - percentage: 49 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 51 + "True": 49 test-flag9650: - percentage: 50 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 50 + "True": 50 test-flag9651: - percentage: 51 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 49 + "True": 51 test-flag9652: - percentage: 52 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 48 + "True": 52 test-flag9653: - percentage: 53 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 47 + "True": 53 test-flag9654: - percentage: 54 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 46 + "True": 54 test-flag9655: - percentage: 55 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 45 + "True": 55 test-flag9656: - percentage: 56 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 44 + "True": 56 test-flag9657: - percentage: 57 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 43 + "True": 57 test-flag9658: - percentage: 58 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 42 + "True": 58 test-flag9659: - percentage: 59 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 41 + "True": 59 test-flag9660: - percentage: 60 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 40 + "True": 60 test-flag9661: - percentage: 61 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 39 + "True": 61 test-flag9662: - percentage: 62 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 38 + "True": 62 test-flag9663: - percentage: 63 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 37 + "True": 63 test-flag9664: - percentage: 64 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 36 + "True": 64 test-flag9665: - percentage: 65 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 35 + "True": 65 test-flag9666: - percentage: 66 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 34 + "True": 66 test-flag9667: - percentage: 67 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 33 + "True": 67 test-flag9668: - percentage: 68 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 32 + "True": 68 test-flag9669: - percentage: 69 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 31 + "True": 69 test-flag9670: - percentage: 70 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 30 + "True": 70 test-flag9671: - percentage: 71 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 29 + "True": 71 test-flag9672: - percentage: 72 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 28 + "True": 72 test-flag9673: - percentage: 73 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 27 + "True": 73 test-flag9674: - percentage: 74 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 26 + "True": 74 test-flag9675: - percentage: 75 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 25 + "True": 75 test-flag9676: - percentage: 76 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 24 + "True": 76 test-flag9677: - percentage: 77 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 23 + "True": 77 test-flag9678: - percentage: 78 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 22 + "True": 78 test-flag9679: - percentage: 79 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 21 + "True": 79 test-flag9680: - percentage: 80 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 20 + "True": 80 test-flag9681: - percentage: 81 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 19 + "True": 81 test-flag9682: - percentage: 82 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 18 + "True": 82 test-flag9683: - percentage: 83 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 17 + "True": 83 test-flag9684: - percentage: 84 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 16 + "True": 84 test-flag9685: - percentage: 85 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 15 + "True": 85 test-flag9686: - percentage: 86 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 14 + "True": 86 test-flag9687: - percentage: 87 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 13 + "True": 87 test-flag9688: - percentage: 88 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 12 + "True": 88 test-flag9689: - percentage: 89 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 11 + "True": 89 test-flag9690: - percentage: 90 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 10 + "True": 90 test-flag9691: - percentage: 91 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 9 + "True": 91 test-flag9692: - percentage: 92 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 8 + "True": 92 test-flag9693: - percentage: 93 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 7 + "True": 93 test-flag9694: - percentage: 94 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 6 + "True": 94 test-flag9695: - percentage: 95 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 5 + "True": 95 test-flag9696: - percentage: 96 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 4 + "True": 96 test-flag9697: - percentage: 97 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 3 + "True": 97 test-flag9698: - percentage: 98 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 2 + "True": 98 test-flag9699: - percentage: 99 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 1 + "True": 99 test-flag9700: - percentage: 0 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 100 + "True": 0 test-flag9701: - percentage: 1 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 99 + "True": 1 test-flag9702: - percentage: 2 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 98 + "True": 2 test-flag9703: - percentage: 3 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 97 + "True": 3 test-flag9704: - percentage: 4 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 96 + "True": 4 test-flag9705: - percentage: 5 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 95 + "True": 5 test-flag9706: - percentage: 6 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 94 + "True": 6 test-flag9707: - percentage: 7 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 93 + "True": 7 test-flag9708: - percentage: 8 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 92 + "True": 8 test-flag9709: - percentage: 9 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 91 + "True": 9 test-flag9710: - percentage: 10 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 90 + "True": 10 test-flag9711: - percentage: 11 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 89 + "True": 11 test-flag9712: - percentage: 12 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 88 + "True": 12 test-flag9713: - percentage: 13 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 87 + "True": 13 test-flag9714: - percentage: 14 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 86 + "True": 14 test-flag9715: - percentage: 15 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 85 + "True": 15 test-flag9716: - percentage: 16 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 84 + "True": 16 test-flag9717: - percentage: 17 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 83 + "True": 17 test-flag9718: - percentage: 18 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 82 + "True": 18 test-flag9719: - percentage: 19 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 81 + "True": 19 test-flag9720: - percentage: 20 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 80 + "True": 20 test-flag9721: - percentage: 21 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 79 + "True": 21 test-flag9722: - percentage: 22 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 78 + "True": 22 test-flag9723: - percentage: 23 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 77 + "True": 23 test-flag9724: - percentage: 24 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 76 + "True": 24 test-flag9725: - percentage: 25 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 75 + "True": 25 test-flag9726: - percentage: 26 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 74 + "True": 26 test-flag9727: - percentage: 27 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 73 + "True": 27 test-flag9728: - percentage: 28 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 72 + "True": 28 test-flag9729: - percentage: 29 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 71 + "True": 29 test-flag9730: - percentage: 30 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 70 + "True": 30 test-flag9731: - percentage: 31 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 69 + "True": 31 test-flag9732: - percentage: 32 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 68 + "True": 32 test-flag9733: - percentage: 33 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 67 + "True": 33 test-flag9734: - percentage: 34 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 66 + "True": 34 test-flag9735: - percentage: 35 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 65 + "True": 35 test-flag9736: - percentage: 36 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 64 + "True": 36 test-flag9737: - percentage: 37 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 63 + "True": 37 test-flag9738: - percentage: 38 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 62 + "True": 38 test-flag9739: - percentage: 39 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 61 + "True": 39 test-flag9740: - percentage: 40 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 60 + "True": 40 test-flag9741: - percentage: 41 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 59 + "True": 41 test-flag9742: - percentage: 42 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 58 + "True": 42 test-flag9743: - percentage: 43 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 57 + "True": 43 test-flag9744: - percentage: 44 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 56 + "True": 44 test-flag9745: - percentage: 45 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 55 + "True": 45 test-flag9746: - percentage: 46 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 54 + "True": 46 test-flag9747: - percentage: 47 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 53 + "True": 47 test-flag9748: - percentage: 48 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 52 + "True": 48 test-flag9749: - percentage: 49 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 51 + "True": 49 test-flag9750: - percentage: 50 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 50 + "True": 50 test-flag9751: - percentage: 51 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 49 + "True": 51 test-flag9752: - percentage: 52 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 48 + "True": 52 test-flag9753: - percentage: 53 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 47 + "True": 53 test-flag9754: - percentage: 54 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 46 + "True": 54 test-flag9755: - percentage: 55 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 45 + "True": 55 test-flag9756: - percentage: 56 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 44 + "True": 56 test-flag9757: - percentage: 57 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 43 + "True": 57 test-flag9758: - percentage: 58 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 42 + "True": 58 test-flag9759: - percentage: 59 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 41 + "True": 59 test-flag9760: - percentage: 60 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 40 + "True": 60 test-flag9761: - percentage: 61 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 39 + "True": 61 test-flag9762: - percentage: 62 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 38 + "True": 62 test-flag9763: - percentage: 63 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 37 + "True": 63 test-flag9764: - percentage: 64 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 36 + "True": 64 test-flag9765: - percentage: 65 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 35 + "True": 65 test-flag9766: - percentage: 66 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 34 + "True": 66 test-flag9767: - percentage: 67 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 33 + "True": 67 test-flag9768: - percentage: 68 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 32 + "True": 68 test-flag9769: - percentage: 69 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 31 + "True": 69 test-flag9770: - percentage: 70 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 30 + "True": 70 test-flag9771: - percentage: 71 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 29 + "True": 71 test-flag9772: - percentage: 72 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 28 + "True": 72 test-flag9773: - percentage: 73 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 27 + "True": 73 test-flag9774: - percentage: 74 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 26 + "True": 74 test-flag9775: - percentage: 75 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 25 + "True": 75 test-flag9776: - percentage: 76 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 24 + "True": 76 test-flag9777: - percentage: 77 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 23 + "True": 77 test-flag9778: - percentage: 78 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 22 + "True": 78 test-flag9779: - percentage: 79 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 21 + "True": 79 test-flag9780: - percentage: 80 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 20 + "True": 80 test-flag9781: - percentage: 81 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 19 + "True": 81 test-flag9782: - percentage: 82 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 18 + "True": 82 test-flag9783: - percentage: 83 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 17 + "True": 83 test-flag9784: - percentage: 84 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 16 + "True": 84 test-flag9785: - percentage: 85 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 15 + "True": 85 test-flag9786: - percentage: 86 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 14 + "True": 86 test-flag9787: - percentage: 87 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 13 + "True": 87 test-flag9788: - percentage: 88 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 12 + "True": 88 test-flag9789: - percentage: 89 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 11 + "True": 89 test-flag9790: - percentage: 90 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 10 + "True": 90 test-flag9791: - percentage: 91 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 9 + "True": 91 test-flag9792: - percentage: 92 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 8 + "True": 92 test-flag9793: - percentage: 93 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 7 + "True": 93 test-flag9794: - percentage: 94 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 6 + "True": 94 test-flag9795: - percentage: 95 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 5 + "True": 95 test-flag9796: - percentage: 96 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 4 + "True": 96 test-flag9797: - percentage: 97 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 3 + "True": 97 test-flag9798: - percentage: 98 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 2 + "True": 98 test-flag9799: - percentage: 99 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 1 + "True": 99 test-flag9800: - percentage: 0 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 100 + "True": 0 test-flag9801: - percentage: 1 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 99 + "True": 1 test-flag9802: - percentage: 2 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 98 + "True": 2 test-flag9803: - percentage: 3 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 97 + "True": 3 test-flag9804: - percentage: 4 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 96 + "True": 4 test-flag9805: - percentage: 5 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 95 + "True": 5 test-flag9806: - percentage: 6 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 94 + "True": 6 test-flag9807: - percentage: 7 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 93 + "True": 7 test-flag9808: - percentage: 8 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 92 + "True": 8 test-flag9809: - percentage: 9 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 91 + "True": 9 test-flag9810: - percentage: 10 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 90 + "True": 10 test-flag9811: - percentage: 11 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 89 + "True": 11 test-flag9812: - percentage: 12 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 88 + "True": 12 test-flag9813: - percentage: 13 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 87 + "True": 13 test-flag9814: - percentage: 14 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 86 + "True": 14 test-flag9815: - percentage: 15 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 85 + "True": 15 test-flag9816: - percentage: 16 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 84 + "True": 16 test-flag9817: - percentage: 17 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 83 + "True": 17 test-flag9818: - percentage: 18 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 82 + "True": 18 test-flag9819: - percentage: 19 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 81 + "True": 19 test-flag9820: - percentage: 20 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 80 + "True": 20 test-flag9821: - percentage: 21 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 79 + "True": 21 test-flag9822: - percentage: 22 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 78 + "True": 22 test-flag9823: - percentage: 23 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 77 + "True": 23 test-flag9824: - percentage: 24 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 76 + "True": 24 test-flag9825: - percentage: 25 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 75 + "True": 25 test-flag9826: - percentage: 26 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 74 + "True": 26 test-flag9827: - percentage: 27 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 73 + "True": 27 test-flag9828: - percentage: 28 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 72 + "True": 28 test-flag9829: - percentage: 29 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 71 + "True": 29 test-flag9830: - percentage: 30 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 70 + "True": 30 test-flag9831: - percentage: 31 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 69 + "True": 31 test-flag9832: - percentage: 32 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 68 + "True": 32 test-flag9833: - percentage: 33 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 67 + "True": 33 test-flag9834: - percentage: 34 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 66 + "True": 34 test-flag9835: - percentage: 35 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 65 + "True": 35 test-flag9836: - percentage: 36 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 64 + "True": 36 test-flag9837: - percentage: 37 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 63 + "True": 37 test-flag9838: - percentage: 38 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 62 + "True": 38 test-flag9839: - percentage: 39 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 61 + "True": 39 test-flag9840: - percentage: 40 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 60 + "True": 40 test-flag9841: - percentage: 41 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 59 + "True": 41 test-flag9842: - percentage: 42 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 58 + "True": 42 test-flag9843: - percentage: 43 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 57 + "True": 43 test-flag9844: - percentage: 44 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 56 + "True": 44 test-flag9845: - percentage: 45 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 55 + "True": 45 test-flag9846: - percentage: 46 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 54 + "True": 46 test-flag9847: - percentage: 47 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 53 + "True": 47 test-flag9848: - percentage: 48 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 52 + "True": 48 test-flag9849: - percentage: 49 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 51 + "True": 49 test-flag9850: - percentage: 50 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 50 + "True": 50 test-flag9851: - percentage: 51 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 49 + "True": 51 test-flag9852: - percentage: 52 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 48 + "True": 52 test-flag9853: - percentage: 53 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 47 + "True": 53 test-flag9854: - percentage: 54 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 46 + "True": 54 test-flag9855: - percentage: 55 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 45 + "True": 55 test-flag9856: - percentage: 56 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 44 + "True": 56 test-flag9857: - percentage: 57 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 43 + "True": 57 test-flag9858: - percentage: 58 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 42 + "True": 58 test-flag9859: - percentage: 59 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 41 + "True": 59 test-flag9860: - percentage: 60 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 40 + "True": 60 test-flag9861: - percentage: 61 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 39 + "True": 61 test-flag9862: - percentage: 62 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 38 + "True": 62 test-flag9863: - percentage: 63 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 37 + "True": 63 test-flag9864: - percentage: 64 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 36 + "True": 64 test-flag9865: - percentage: 65 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 35 + "True": 65 test-flag9866: - percentage: 66 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 34 + "True": 66 test-flag9867: - percentage: 67 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 33 + "True": 67 test-flag9868: - percentage: 68 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 32 + "True": 68 test-flag9869: - percentage: 69 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 31 + "True": 69 test-flag9870: - percentage: 70 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 30 + "True": 70 test-flag9871: - percentage: 71 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 29 + "True": 71 test-flag9872: - percentage: 72 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 28 + "True": 72 test-flag9873: - percentage: 73 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 27 + "True": 73 test-flag9874: - percentage: 74 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 26 + "True": 74 test-flag9875: - percentage: 75 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 25 + "True": 75 test-flag9876: - percentage: 76 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 24 + "True": 76 test-flag9877: - percentage: 77 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 23 + "True": 77 test-flag9878: - percentage: 78 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 22 + "True": 78 test-flag9879: - percentage: 79 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 21 + "True": 79 test-flag9880: - percentage: 80 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 20 + "True": 80 test-flag9881: - percentage: 81 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 19 + "True": 81 test-flag9882: - percentage: 82 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 18 + "True": 82 test-flag9883: - percentage: 83 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 17 + "True": 83 test-flag9884: - percentage: 84 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 16 + "True": 84 test-flag9885: - percentage: 85 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 15 + "True": 85 test-flag9886: - percentage: 86 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 14 + "True": 86 test-flag9887: - percentage: 87 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 13 + "True": 87 test-flag9888: - percentage: 88 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 12 + "True": 88 test-flag9889: - percentage: 89 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 11 + "True": 89 test-flag9890: - percentage: 90 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 10 + "True": 90 test-flag9891: - percentage: 91 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 9 + "True": 91 test-flag9892: - percentage: 92 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 8 + "True": 92 test-flag9893: - percentage: 93 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 7 + "True": 93 test-flag9894: - percentage: 94 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 6 + "True": 94 test-flag9895: - percentage: 95 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 5 + "True": 95 test-flag9896: - percentage: 96 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 4 + "True": 96 test-flag9897: - percentage: 97 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 3 + "True": 97 test-flag9898: - percentage: 98 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 2 + "True": 98 test-flag9899: - percentage: 99 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 1 + "True": 99 test-flag9900: - percentage: 0 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 100 + "True": 0 test-flag9901: - percentage: 1 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 99 + "True": 1 test-flag9902: - percentage: 2 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 98 + "True": 2 test-flag9903: - percentage: 3 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 97 + "True": 3 test-flag9904: - percentage: 4 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 96 + "True": 4 test-flag9905: - percentage: 5 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 95 + "True": 5 test-flag9906: - percentage: 6 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 94 + "True": 6 test-flag9907: - percentage: 7 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 93 + "True": 7 test-flag9908: - percentage: 8 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 92 + "True": 8 test-flag9909: - percentage: 9 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 91 + "True": 9 test-flag9910: - percentage: 10 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 90 + "True": 10 test-flag9911: - percentage: 11 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 89 + "True": 11 test-flag9912: - percentage: 12 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 88 + "True": 12 test-flag9913: - percentage: 13 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 87 + "True": 13 test-flag9914: - percentage: 14 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 86 + "True": 14 test-flag9915: - percentage: 15 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 85 + "True": 15 test-flag9916: - percentage: 16 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 84 + "True": 16 test-flag9917: - percentage: 17 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 83 + "True": 17 test-flag9918: - percentage: 18 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 82 + "True": 18 test-flag9919: - percentage: 19 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 81 + "True": 19 test-flag9920: - percentage: 20 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 80 + "True": 20 test-flag9921: - percentage: 21 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 79 + "True": 21 test-flag9922: - percentage: 22 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 78 + "True": 22 test-flag9923: - percentage: 23 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 77 + "True": 23 test-flag9924: - percentage: 24 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 76 + "True": 24 test-flag9925: - percentage: 25 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 75 + "True": 25 test-flag9926: - percentage: 26 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 74 + "True": 26 test-flag9927: - percentage: 27 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 73 + "True": 27 test-flag9928: - percentage: 28 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 72 + "True": 28 test-flag9929: - percentage: 29 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 71 + "True": 29 test-flag9930: - percentage: 30 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 70 + "True": 30 test-flag9931: - percentage: 31 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 69 + "True": 31 test-flag9932: - percentage: 32 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 68 + "True": 32 test-flag9933: - percentage: 33 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 67 + "True": 33 test-flag9934: - percentage: 34 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 66 + "True": 34 test-flag9935: - percentage: 35 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 65 + "True": 35 test-flag9936: - percentage: 36 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 64 + "True": 36 test-flag9937: - percentage: 37 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 63 + "True": 37 test-flag9938: - percentage: 38 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 62 + "True": 38 test-flag9939: - percentage: 39 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 61 + "True": 39 test-flag9940: - percentage: 40 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 60 + "True": 40 test-flag9941: - percentage: 41 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 59 + "True": 41 test-flag9942: - percentage: 42 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 58 + "True": 42 test-flag9943: - percentage: 43 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 57 + "True": 43 test-flag9944: - percentage: 44 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 56 + "True": 44 test-flag9945: - percentage: 45 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 55 + "True": 45 test-flag9946: - percentage: 46 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 54 + "True": 46 test-flag9947: - percentage: 47 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 53 + "True": 47 test-flag9948: - percentage: 48 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 52 + "True": 48 test-flag9949: - percentage: 49 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 51 + "True": 49 test-flag9950: - percentage: 50 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 50 + "True": 50 test-flag9951: - percentage: 51 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 49 + "True": 51 test-flag9952: - percentage: 52 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 48 + "True": 52 test-flag9953: - percentage: 53 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 47 + "True": 53 test-flag9954: - percentage: 54 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 46 + "True": 54 test-flag9955: - percentage: 55 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 45 + "True": 55 test-flag9956: - percentage: 56 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 44 + "True": 56 test-flag9957: - percentage: 57 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 43 + "True": 57 test-flag9958: - percentage: 58 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 42 + "True": 58 test-flag9959: - percentage: 59 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 41 + "True": 59 test-flag9960: - percentage: 60 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 40 + "True": 60 test-flag9961: - percentage: 61 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 39 + "True": 61 test-flag9962: - percentage: 62 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 38 + "True": 62 test-flag9963: - percentage: 63 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 37 + "True": 63 test-flag9964: - percentage: 64 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 36 + "True": 64 test-flag9965: - percentage: 65 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 35 + "True": 65 test-flag9966: - percentage: 66 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 34 + "True": 66 test-flag9967: - percentage: 67 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 33 + "True": 67 test-flag9968: - percentage: 68 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 32 + "True": 68 test-flag9969: - percentage: 69 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 31 + "True": 69 test-flag9970: - percentage: 70 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 30 + "True": 70 test-flag9971: - percentage: 71 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 29 + "True": 71 test-flag9972: - percentage: 72 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 28 + "True": 72 test-flag9973: - percentage: 73 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 27 + "True": 73 test-flag9974: - percentage: 74 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 26 + "True": 74 test-flag9975: - percentage: 75 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 25 + "True": 75 test-flag9976: - percentage: 76 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 24 + "True": 76 test-flag9977: - percentage: 77 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 23 + "True": 77 test-flag9978: - percentage: 78 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 22 + "True": 78 test-flag9979: - percentage: 79 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 21 + "True": 79 test-flag9980: - percentage: 80 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 20 + "True": 80 test-flag9981: - percentage: 81 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 19 + "True": 81 test-flag9982: - percentage: 82 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 18 + "True": 82 test-flag9983: - percentage: 83 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 17 + "True": 83 test-flag9984: - percentage: 84 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 16 + "True": 84 test-flag9985: - percentage: 85 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 15 + "True": 85 test-flag9986: - percentage: 86 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 14 + "True": 86 test-flag9987: - percentage: 87 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 13 + "True": 87 test-flag9988: - percentage: 88 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 12 + "True": 88 test-flag9989: - percentage: 89 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 11 + "True": 89 test-flag9990: - percentage: 90 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 10 + "True": 90 test-flag9991: - percentage: 91 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 9 + "True": 91 test-flag9992: - percentage: 92 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 8 + "True": 92 test-flag9993: - percentage: 93 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 7 + "True": 93 test-flag9994: - percentage: 94 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 6 + "True": 94 test-flag9995: - percentage: 95 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 5 + "True": 95 test-flag9996: - percentage: 96 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 4 + "True": 96 test-flag9997: - percentage: 97 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 3 + "True": 97 test-flag9998: - percentage: 98 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 2 + "True": 98 test-flag9999: - percentage: 99 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + defaultRule: + name: legacyDefaultRule + percentage: + "False": 1 + "True": 99 diff --git a/testdata/flag-config-scheduled-v0.yaml b/testdata/flag-config-scheduled-v0.yaml old mode 100644 new mode 100755 index 0bf836ad67e..5261da47d1a --- a/testdata/flag-config-scheduled-v0.yaml +++ b/testdata/flag-config-scheduled-v0.yaml @@ -1,26 +1,52 @@ test-flag: - rule: key eq "random-key" - percentage: 100 - true: true - false: false - default: false - rollout: - scheduled: - - date: 2022-08-01T00:00:00.10+02:00 - rule: beta eq "true" - percentage: 100 - - - date: 2022-05-12T15:36:00.10+02:00 - rule: beta eq "false" - percentage: 0 - - - date: 2022-05-12T15:36:00.10+02:00 - rule: "" - - + variations: + Default: false + "False": false + "True": true + targeting: + - name: legacyRuleV0 + query: key eq "random-key" + percentage: + "False": 0 + "True": 100 + defaultRule: + name: legacyDefaultRule + variation: Default + scheduledRollout: + - targeting: + - name: legacyRuleV0 + query: beta eq "true" + variation: "" + percentage: + "False": 0 + "True": 100 + disable: false + date: 2022-08-01T00:00:00.1+02:00 + - targeting: + - name: legacyRuleV0 + query: beta eq "false" + variation: "" + percentage: + "False": 100 + "True": 0 + disable: false + date: 2022-05-12T15:36:00.1+02:00 + - targeting: + - name: legacyRuleV0 + query: "" + disable: false + date: 2022-05-12T15:36:00.1+02:00 test-flag2: - rule: key eq "not-a-key" - percentage: 100 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + targeting: + - name: legacyRuleV0 + query: key eq "not-a-key" + percentage: + "False": 0 + "True": 100 + defaultRule: + name: legacyDefaultRule + variation: Default diff --git a/testdata/flag-config-updated.yaml b/testdata/flag-config-updated.yaml index 5f7aa82a706..9e64746a337 100644 --- a/testdata/flag-config-updated.yaml +++ b/testdata/flag-config-updated.yaml @@ -1,13 +1,29 @@ test-flag: - rule: key eq "random-key" - percentage: 99 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + targeting: + - name: legacyRuleV0 + query: key eq "random-key" + percentage: + "False": 1 + "True": 99 + defaultRule: + name: legacyDefaultRule + variation: Default test-flag2: - rule: key eq "not-a-key" - percentage: 100 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + targeting: + - name: legacyRuleV0 + query: key eq "not-a-key" + percentage: + "False": 0 + "True": 100 + defaultRule: + name: legacyDefaultRule + variation: Default diff --git a/testdata/test-instance2.yaml b/testdata/test-instance2.yaml old mode 100644 new mode 100755 index 3ddd92eadc3..479fc4ca5a7 --- a/testdata/test-instance2.yaml +++ b/testdata/test-instance2.yaml @@ -1,13 +1,29 @@ test-flag: - rule: key eq "random-key" - percentage: 0 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + targeting: + - name: legacyRuleV0 + query: key eq "random-key" + percentage: + "False": 100 + "True": 0 + defaultRule: + name: legacyDefaultRule + variation: Default test-flag2: - rule: key eq "not-a-key" - percentage: 100 - true: true - false: false - default: false + variations: + Default: false + "False": false + "True": true + targeting: + - name: legacyRuleV0 + query: key eq "not-a-key" + percentage: + "False": 0 + "True": 100 + defaultRule: + name: legacyDefaultRule + variation: Default