| // Copyright 2021 The Fuchsia Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| package go_bindings_test |
| |
| import ( |
| "testing" |
| |
| "fidl/fidl/go/types" |
| ) |
| |
| func TestBitsApi(t *testing.T) { |
| var knownBits, unknownBits uint64 = 0b101, 0b110000 |
| unknownStrict := types.StrictBits(knownBits | unknownBits) |
| if !unknownStrict.HasUnknownBits() { |
| t.Error("unknown bits returned false for HasUnknownBits") |
| } |
| if unknownStrict.GetUnknownBits() != unknownBits { |
| t.Errorf( |
| "Got wrong unknown bits: expected %b, was %b", unknownBits, unknownStrict.GetUnknownBits()) |
| } |
| if unknownStrict.InvertBits() != 0b10 { |
| t.Errorf( |
| "Got wrong InvertBits: expected %b, got %b", 0b10, unknownStrict.InvertBits()) |
| } |
| if unknownStrict.InvertBits().InvertBits() != types.StrictBits(knownBits) { |
| t.Errorf( |
| "Got wrong double InvertBits: expected %b, got %b", knownBits, unknownStrict.InvertBits().InvertBits()) |
| } |
| if !unknownStrict.HasBits(0b1) { |
| t.Errorf("Failed to match on known bits for HasBits") |
| } |
| if !unknownStrict.HasBits(0b110000) { |
| t.Errorf("Failed to match on unknown bits for HasBits") |
| } |
| if unknownStrict.HasBits(0b10) { |
| t.Errorf("Matched on known bits for HasBits when it should not") |
| } |
| if unknownStrict.HasBits(0b1000) { |
| t.Errorf("Matched on unknown bits for HasBits when it should not") |
| } |
| if unknownStrict.ClearBits(0b1) != types.StrictBits(0b110100) { |
| t.Errorf("Failed to clear known bits for ClearBits") |
| } |
| if unknownStrict.ClearBits(0b10000) != types.StrictBits(0b100101) { |
| t.Errorf("Failed to clear unknown bits for ClearBits") |
| } |
| if unknownStrict != unknownStrict.ClearBits(0b10) { |
| t.Errorf("Cleared known bits when it should not") |
| } |
| if unknownStrict != unknownStrict.ClearBits(0b1000) { |
| t.Errorf("Cleared unknown bits when it should not") |
| } |
| |
| knownStrict := unknownStrict & types.StrictBits_Mask |
| if expected := types.StrictBitsMemberA | types.StrictBitsMemberC; knownStrict != expected { |
| t.Errorf("Expected masked value: %b, got %b", expected, knownStrict) |
| } |
| } |
| |
| func TestFlexibleBitsApi(t *testing.T) { |
| var knownBits, unknownBits uint64 = 0b110000, 0b101 |
| unknownFlexible := types.FlexibleBits(knownBits | unknownBits) |
| if !unknownFlexible.HasUnknownBits() { |
| t.Error("unknown bits returned false for HasUnknownBits") |
| } |
| if unknownFlexible.GetUnknownBits() != unknownBits { |
| t.Errorf( |
| "Got wrong unknown bits: expected %b, was %b", unknownBits, unknownFlexible.GetUnknownBits()) |
| } |
| if unknownFlexible.InvertBits() != 0b001000 { |
| t.Errorf( |
| "Got wrong InvertBits: expected %b, got %b", 0b001000, unknownFlexible.InvertBits()) |
| } |
| if unknownFlexible.InvertBits().InvertBits() != types.FlexibleBits(knownBits) { |
| t.Errorf( |
| "Got wrong double InvertBits: expected %b, got %b", knownBits, unknownFlexible.InvertBits().InvertBits()) |
| } |
| if !unknownFlexible.HasBits(0b1) { |
| t.Errorf("Failed to match on known bits for HasBits") |
| } |
| if !unknownFlexible.HasBits(0b110000) { |
| t.Errorf("Failed to match on unknown bits for HasBits") |
| } |
| if unknownFlexible.HasBits(0b10) { |
| t.Errorf("Matched on known bits for HasBits when it should not") |
| } |
| if unknownFlexible.HasBits(0b1000) { |
| t.Errorf("Matched on unknown bits for HasBits when it should not") |
| } |
| if unknownFlexible.ClearBits(0b1) != types.FlexibleBits(0b110100) { |
| t.Errorf("Failed to clear known bits for ClearBits") |
| } |
| if unknownFlexible.ClearBits(0b10000) != types.FlexibleBits(0b100101) { |
| t.Errorf("Failed to clear unknown bits for ClearBits") |
| } |
| if unknownFlexible != unknownFlexible.ClearBits(0b10) { |
| t.Errorf("Cleared known bits when it should not") |
| } |
| if unknownFlexible != unknownFlexible.ClearBits(0b1000) { |
| t.Errorf("Cleared unknown bits when it should not") |
| } |
| |
| knownFlexible := unknownFlexible & types.FlexibleBits_Mask |
| if expected := types.FlexibleBitsMemberB | types.FlexibleBitsMemberC; knownFlexible != expected { |
| t.Errorf("Expected masked value: %b, got %b", expected, knownFlexible) |
| } |
| } |
| |
| func TestBitsInvertBits(t *testing.T) { |
| cases := []struct { |
| left, right types.StrictBits |
| }{ |
| {types.StrictBits(0), types.StrictBitsMemberA | types.StrictBitsMemberB | types.StrictBitsMemberC}, |
| {types.StrictBitsMemberA, types.StrictBitsMemberB | types.StrictBitsMemberC}, |
| {types.StrictBitsMemberB, types.StrictBitsMemberA | types.StrictBitsMemberC}, |
| {types.StrictBitsMemberC, types.StrictBitsMemberA | types.StrictBitsMemberB}, |
| } |
| for _, ex := range cases { |
| if ex.left.InvertBits() != ex.right { |
| t.Errorf("%s should invert to %s", ex.left, ex.right) |
| } |
| if ex.right.InvertBits() != ex.left { |
| t.Errorf("%s should invert to %s", ex.right, ex.left) |
| } |
| } |
| } |
| |
| func TestBitsHasBits(t *testing.T) { |
| all := []types.StrictBits{ |
| types.StrictBitsMemberA, |
| types.StrictBitsMemberB, |
| types.StrictBitsMemberC, |
| } |
| cases := []struct { |
| val types.StrictBits |
| has []types.StrictBits |
| }{ |
| {types.StrictBits(0), nil}, |
| {types.StrictBitsMemberA, []types.StrictBits{ |
| types.StrictBitsMemberA, |
| }}, |
| {types.StrictBitsMemberA | types.StrictBitsMemberC, []types.StrictBits{ |
| types.StrictBitsMemberA, |
| types.StrictBitsMemberC, |
| }}, |
| } |
| for _, ex := range cases { |
| hasOrHasNot := make(map[types.StrictBits]bool) |
| for _, b := range ex.has { |
| hasOrHasNot[b] = true |
| } |
| for _, b := range all { |
| if hasOrHasNot[b] { |
| if !ex.val.HasBits(b) { |
| t.Errorf("%s should have bits %s", ex.val, b) |
| } |
| } else { |
| if ex.val.HasBits(b) { |
| t.Errorf("%s should not have bits %s", ex.val, b) |
| } |
| } |
| } |
| } |
| } |