func Usage(cmd string) {
fmt.Println(strings.Repeat("-", 100))
fmt.Println("Ssh version Check by haifeng11")
fmt.Println("Usage:")
fmt.Printf("%s iplist_file\n", cmd)
fmt.Println(strings.Repeat("-", 100))
}
func TestKVPutError(t *testing.T) {
defer testutil.AfterTest(t)
var (
maxReqBytes = 1.5 * 1024 * 1024
quota = int64(maxReqBytes * 1.2)
)
clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 1, QuotaBackendBytes: quota})
defer clus.Terminate(t)
kv := clientv3.NewKV(clus.RandClient())
ctx := context.TODO()
_, err := kv.Put(ctx, "", "bar")
if err != rpctypes.ErrEmptyKey {
t.Fatalf("expected %v, got %v", rpctypes.ErrEmptyKey, err)
}
_, err = kv.Put(ctx, "key", strings.Repeat("a", int(maxReqBytes+100))) // 1.5MB
if err != rpctypes.ErrRequestTooLarge {
t.Fatalf("expected %v, got %v", rpctypes.ErrRequestTooLarge, err)
}
_, err = kv.Put(ctx, "foo1", strings.Repeat("a", int(maxReqBytes-50)))
if err != nil { // below quota
t.Fatal(err)
}
time.Sleep(500 * time.Millisecond) // give enough time for commit
_, err = kv.Put(ctx, "foo2", strings.Repeat("a", int(maxReqBytes-50)))
if err != rpctypes.ErrNoSpace { // over quota
t.Fatalf("expected %v, got %v", rpctypes.ErrNoSpace, err)
}
}
func formatTwoColumns(w io.Writer, indent, padding, width int, rows [][2]string) {
// Find size of first column.
s := 0
for _, row := range rows {
if c := len(row[0]); c > s && c < 30 {
s = c
}
}
indentStr := strings.Repeat(" ", indent)
offsetStr := strings.Repeat(" ", s+padding)
for _, row := range rows {
buf := bytes.NewBuffer(nil)
doc.ToText(buf, row[1], "", preIndent, width-s-padding-indent)
lines := strings.Split(strings.TrimRight(buf.String(), "\n"), "\n")
fmt.Fprintf(w, "%s%-*s%*s", indentStr, s, row[0], padding, "")
if len(row[0]) >= 30 {
fmt.Fprintf(w, "\n%s%s", indentStr, offsetStr)
}
fmt.Fprintf(w, "%s\n", lines[0])
for _, line := range lines[1:] {
fmt.Fprintf(w, "%s%s%s\n", indentStr, offsetStr, line)
}
}
}
func TestValidFieldNames(t *testing.T) {
testCases := []struct {
name string
valid bool
}{
{"Normal", true},
{"Also_OK_123", true},
{"Not so great", false},
{"lower_case", false},
{"Exclaim!", false},
{"Hello세상아 안녕", false},
{"", false},
{"Hεllo", false},
{strings.Repeat("A", 500), true},
{strings.Repeat("A", 501), false},
}
for _, tc := range testCases {
_, _, err := saveDoc(&FieldList{
Field{Name: tc.name, Value: "val"},
})
if err != nil && !strings.Contains(err.Error(), "invalid field name") {
t.Errorf("unexpected err %q for field name %q", err, tc.name)
}
if (err == nil) != tc.valid {
t.Errorf("field %q: expected valid %t, received err %v", tc.name, tc.valid, err)
}
}
}
func TestIsDelegation(t *testing.T) {
f := require.False
tr := require.True
for val, check := range map[string]func(require.TestingT, bool, ...interface{}){
// false checks
path.Join(CanonicalTargetsRole, strings.Repeat("x", 255-len(CanonicalTargetsRole))): f,
"": f,
CanonicalRootRole: f,
path.Join(CanonicalRootRole, "level1"): f,
CanonicalTargetsRole: f,
CanonicalTargetsRole + "/": f,
path.Join(CanonicalTargetsRole, "level1") + "/": f,
path.Join(CanonicalTargetsRole, "UpperCase"): f,
path.Join(CanonicalTargetsRole, "directory") + "/../../traversal": f,
CanonicalTargetsRole + "///test/middle/slashes": f,
CanonicalTargetsRole + "/./././": f,
path.Join(" ", CanonicalTargetsRole, "level1"): f,
path.Join(" "+CanonicalTargetsRole, "level1"): f,
path.Join(CanonicalTargetsRole, "level1"+" "): f,
path.Join(CanonicalTargetsRole, "white space"+"level2"): f,
path.Join(CanonicalTargetsRole, strings.Repeat("x", 256-len(CanonicalTargetsRole))): f,
// true checks
path.Join(CanonicalTargetsRole, "level1"): tr,
path.Join(CanonicalTargetsRole, "level1", "level2", "level3"): tr,
path.Join(CanonicalTargetsRole, "under_score"): tr,
path.Join(CanonicalTargetsRole, "hyphen-hyphen"): tr,
} {
check(t, IsDelegation(val))
}
}
func TestValidateLogGroupName(t *testing.T) {
validNames := []string{
"ValidLogGroupName",
"ValidLogGroup.Name",
"valid/Log-group",
"1234",
"YadaValid#0123",
"Also_valid-name",
strings.Repeat("W", 512),
}
for _, v := range validNames {
_, errors := validateLogGroupName(v, "name")
if len(errors) != 0 {
t.Fatalf("%q should be a valid Log Metric Filter Transformation Name: %q", v, errors)
}
}
invalidNames := []string{
"Here is a name with: colon",
"and here is another * invalid name",
"also $ invalid",
"This . is also %% invalid@!)+(",
"*",
"",
// length > 512
strings.Repeat("W", 513),
}
for _, v := range invalidNames {
_, errors := validateLogGroupName(v, "name")
if len(errors) == 0 {
t.Fatalf("%q should be an invalid Log Metric Filter Transformation Name", v)
}
}
}
func TestValidateS3BucketLifecycleRuleId(t *testing.T) {
validId := []string{
"YadaHereAndThere",
"Valid-5Rule_ID",
"This . is also %% valid@!)+*(:ID",
"1234",
strings.Repeat("W", 255),
}
for _, v := range validId {
_, errors := validateS3BucketLifecycleRuleId(v, "id")
if len(errors) != 0 {
t.Fatalf("%q should be a valid lifecycle rule id: %q", v, errors)
}
}
invalidId := []string{
// length > 255
strings.Repeat("W", 256),
}
for _, v := range invalidId {
_, errors := validateS3BucketLifecycleRuleId(v, "id")
if len(errors) == 0 {
t.Fatalf("%q should be an invalid lifecycle rule id", v)
}
}
}
func TestIsValidLabelValue(t *testing.T) {
successCases := []string{
"simple",
"now-with-dashes",
"1-starts-with-num",
"end-with-num-1",
"1234", // only num
strings.Repeat("a", 63), // to the limit
"", // empty value
}
for i := range successCases {
if !IsValidLabelValue(successCases[i]) {
t.Errorf("case %s expected success", successCases[i])
}
}
errorCases := []string{
"nospecialchars%^=@",
"Tama-nui-te-rā.is.Māori.sun",
"\\backslashes\\are\\bad",
"-starts-with-dash",
"ends-with-dash-",
".starts.with.dot",
"ends.with.dot.",
strings.Repeat("a", 64), // over the limit
}
for i := range errorCases {
if IsValidLabelValue(errorCases[i]) {
t.Errorf("case[%d] expected failure", i)
}
}
}
func TestIsDNS952Label(t *testing.T) {
goodValues := []string{
"a", "ab", "abc", "a1", "a-1", "a--1--2--b",
strings.Repeat("a", 24),
}
for _, val := range goodValues {
if !IsDNS952Label(val) {
t.Errorf("expected true for '%s'", val)
}
}
badValues := []string{
"0", "01", "012", "1a", "1-a", "1--a--b--2",
"", "A", "ABC", "aBc", "A1", "A-1", "1-A",
"-", "a-", "-a", "1-", "-1",
"_", "a_", "_a", "a_b", "1_", "_1", "1_2",
".", "a.", ".a", "a.b", "1.", ".1", "1.2",
" ", "a ", " a", "a b", "1 ", " 1", "1 2",
strings.Repeat("a", 25),
}
for _, val := range badValues {
if IsDNS952Label(val) {
t.Errorf("expected false for '%s'", val)
}
}
}
func TestBasic(t *testing.T) {
testLiterals(t, []string{
strings.Repeat("a", 1000),
strings.Repeat("b", 97270),
strings.Repeat("c", 8000),
})
}
func (s *SudokuSolver) Eureka(O *Solution) {
grid := make([][]int, s.Dim)
for i := 0; i < s.Dim; i++ {
grid[i] = make([]int, s.Dim)
}
for _, n := range *O {
nodes := make([]*Node, 4)
nodes = append(nodes, n)
for m := n.Right; n != m; m = m.Right {
nodes = append(nodes, m)
}
x, y, digit := s.coverToGrid(nodes)
grid[x][y] = digit
}
sdim := int(math.Sqrt(float64(s.Dim)))
delim := "+" + strings.Repeat(strings.Repeat("-", sdim*2+1)+"+", sdim)
for i, line := range grid {
if i%sdim == 0 {
fmt.Println(delim)
}
for j, cell := range line {
if j%sdim == 0 {
if j > 0 {
fmt.Print(" ")
}
fmt.Print("|")
}
fmt.Print(" ", cell)
}
fmt.Print(" |\n")
}
fmt.Println(delim)
}
func TestNoIndexOnSliceProperties(t *testing.T) {
// Check that ExcludeFromIndexes is set on the inner elements,
// rather than the top-level ArrayValue value.
ctx := context.Background()
pl := PropertyList{
Property{
Name: "repeated",
Value: []interface{}{
123,
false,
"short",
strings.Repeat("a", 1503),
},
NoIndex: true,
},
}
key := NewKey(ctx, "dummy", "dummy", 0, nil)
entity, err := saveEntity(key, &pl)
if err != nil {
t.Fatalf("saveEntity: %v", err)
}
want := &pb.Value{
ValueType: &pb.Value_ArrayValue{&pb.ArrayValue{[]*pb.Value{
{ValueType: &pb.Value_IntegerValue{123}, ExcludeFromIndexes: true},
{ValueType: &pb.Value_BooleanValue{false}, ExcludeFromIndexes: true},
{ValueType: &pb.Value_StringValue{"short"}, ExcludeFromIndexes: true},
{ValueType: &pb.Value_StringValue{strings.Repeat("a", 1503)}, ExcludeFromIndexes: true},
}}},
}
if got := entity.Properties["repeated"]; !proto.Equal(got, want) {
t.Errorf("Entity proto differs\ngot: %v\nwant: %v", got, want)
}
}
func TestRandomBuildTag(t *testing.T) {
tests := []struct {
namespace, name string
want string
}{
{"test", "build-1", "test/build-1:f1f85ff5"},
// For long build namespace + build name, the returned random build tag
// would be longer than the limit of reference.NameTotalLengthMax (255
// chars). We do not truncate the repository name because it could create an
// invalid repository name (e.g., namespace=abc, name=d, repo=abc/d,
// trucated=abc/ -> invalid), so we simply take a SHA1 hash of the
// repository name (which is guaranteed to be a valid repository name) and
// preserve the random tag.
{
"namespace" + strings.Repeat(".namespace", 20),
"name" + strings.Repeat(".name", 20),
"47c1d5c686ce4563521c625457e79ca23c07bc27:f1f85ff5",
},
}
for _, tt := range tests {
rand.Seed(0)
got := randomBuildTag(tt.namespace, tt.name)
if !reflect.DeepEqual(got, tt.want) {
t.Errorf("randomBuildTag(%q, %q) = %q, want %q", tt.namespace, tt.name, got, tt.want)
}
}
}
func (t *RandomReaderTest) UpgradesSequentialReads_ExistingReader() {
t.object.Size = 1 << 40
const readSize = 10
// Simulate an existing reader at the correct offset, which will be exhausted
// by the read below.
const existingSize = 3
r := strings.NewReader(strings.Repeat("x", existingSize))
t.rr.wrapped.reader = ioutil.NopCloser(r)
t.rr.wrapped.cancel = func() {}
t.rr.wrapped.start = 1
t.rr.wrapped.limit = 1 + existingSize
// The bucket should be asked to read up to the end of the object.
r = strings.NewReader(strings.Repeat("x", readSize-existingSize))
rc := ioutil.NopCloser(r)
ExpectCall(t.bucket, "NewReader")(
Any(),
AllOf(rangeStartIs(1+existingSize), rangeLimitIs(t.object.Size))).
WillOnce(Return(rc, nil))
// Call through.
buf := make([]byte, readSize)
t.rr.ReadAt(buf, 1)
// Check the state now.
ExpectEq(1+readSize, t.rr.wrapped.start)
ExpectEq(t.object.Size, t.rr.wrapped.limit)
}
func CreateTable(tbl PicklesTableArgument) string {
Html := ""
if len(tbl.HeaderRow) > 0 {
Html += "<table>"
for n, y := range tbl.DataRows {
if n == 1 && y[0] == strings.Repeat("-", strings.Count(y[0], "")-1) {
continue
}
if n == len(tbl.DataRows)-1 && y[0] == strings.Repeat("-", strings.Count(y[0], "")-1) {
continue
}
//fmt.Printf("ligne %d grp[%s] chaine lue [%s] taille:[%d] chaine de tiret [%s]\n",n,y,y[0],strings.Count(y[0],""),strings.Repeat("-", strings.Count(y[0],"")))
Html += "<tr>"
for _, z := range y {
if n == 0 {
Html += fmt.Sprintf("<th>%s</th>", z)
} else {
Html += fmt.Sprintf("<td>%s</td>", z)
}
}
Html += "</tr>"
//fmt.Printf("TableArgument.DataRows[%d]: %v\n", n,y)
}
Html += "</table>"
// debug log.Fatalf("Stop %s",Html)
}
return Html
}
func TestValidateDomain(t *testing.T) {
assert.False(t, ValidateDomainPart(strings.Repeat("a", 256)),
"Max domain length is 255")
assert.False(t, ValidateDomainPart(strings.Repeat("a", 64)+".com"),
"Max label length is 63")
assert.True(t, ValidateDomainPart(strings.Repeat("a", 63)+".com"),
"Should allow 63 char label")
var testTable = []struct {
input string
expect bool
msg string
}{
{"", false, "Empty domain is not valid"},
{"hostname", true, "Just a hostname is valid"},
{"github.com", true, "Two labels should be just fine"},
{"my-domain.com", true, "Hyphen is allowed mid-label"},
{"_domainkey.foo.com", true, "Underscores are allowed"},
{"bar.com.", true, "Must be able to end with a dot"},
{"ABC.6DBS.com", true, "Mixed case is OK"},
{"mail.123.com", true, "Number only label valid"},
{"123.com", true, "Number only label valid"},
{"google..com", false, "Double dot not valid"},
{".foo.com", false, "Cannot start with a dot"},
{"google\r.com", false, "Special chars not allowed"},
{"foo.-bar.com", false, "Label cannot start with hyphen"},
{"foo-.bar.com", false, "Label cannot end with hyphen"},
}
for _, tt := range testTable {
if ValidateDomainPart(tt.input) != tt.expect {
t.Errorf("Expected %v for %q: %s", tt.expect, tt.input, tt.msg)
}
}
}
func TestValidateLogMetricTransformationName(t *testing.T) {
validNames := []string{
"YadaHereAndThere",
"Valid-5Metric_Name",
"This . is also %% valid@!)+(",
"1234",
"",
strings.Repeat("W", 255),
}
for _, v := range validNames {
_, errors := validateLogMetricFilterTransformationName(v, "name")
if len(errors) != 0 {
t.Fatalf("%q should be a valid Log Metric Filter Transformation Name: %q", v, errors)
}
}
invalidNames := []string{
"Here is a name with: colon",
"and here is another * invalid name",
"also $ invalid",
"*",
// length > 255
strings.Repeat("W", 256),
}
for _, v := range invalidNames {
_, errors := validateLogMetricFilterTransformationName(v, "name")
if len(errors) == 0 {
t.Fatalf("%q should be an invalid Log Metric Filter Transformation Name", v)
}
}
}
// PrintRunningStep ...
func PrintRunningStep(title, version string, idx int) {
if len(version) > 25 {
version = "..." + stringutil.MaxLastChars(version, 22)
}
content := fmt.Sprintf("| (%d) %s (%s) |", idx, title, version)
charDiff := len(content) - stepRunSummaryBoxWidthInChars
if charDiff < 0 {
// shorter than desired - fill with space
content = fmt.Sprintf("| (%d) %s (%s)%s |", idx, title, version, strings.Repeat(" ", -charDiff))
} else if charDiff > 0 {
// longer than desired - trim title
trimmedTitleWidth := len(title) - charDiff - 3
if trimmedTitleWidth < 0 {
log.Errorf("Step Version too long, can't present title at all! : %s", version)
} else {
content = fmt.Sprintf("| (%d) %s... (%s) |", idx, title[0:trimmedTitleWidth], version)
}
}
sep := strings.Repeat("-", len(content))
log.Info(sep)
log.Infof(content)
log.Info(sep)
log.Info("|" + strings.Repeat(" ", stepRunSummaryBoxWidthInChars-2) + "|")
}
func TestValidateS3BucketReplicationRulePrefix(t *testing.T) {
validId := []string{
"YadaHereAndThere",
"Valid-5Rule_ID",
"This . is also %% valid@!)+*(:ID",
"1234",
strings.Repeat("W", 1024),
}
for _, v := range validId {
_, errors := validateS3BucketReplicationRulePrefix(v, "id")
if len(errors) != 0 {
t.Fatalf("%q should be a valid lifecycle rule id: %q", v, errors)
}
}
invalidId := []string{
// length > 1024
strings.Repeat("W", 1025),
}
for _, v := range invalidId {
_, errors := validateS3BucketReplicationRulePrefix(v, "id")
if len(errors) == 0 {
t.Fatalf("%q should be an invalid replication configuration rule id", v)
}
}
}
func drawKnownMaildirs(amua *Amua, g *gocui.Gui, v *gocui.View) error {
v.Clear()
v.Frame = false
w, h := v.Size()
displayed := len(amua.knownMaildirs)
if len(amua.knownMaildirs) > h {
displayed = h
}
fillers := h - displayed
space := 1
for i := 0; i < displayed; i++ {
current := amua.knownMaildirs[i].maildir == amua.curMaildirView.md
nrMsgs := fmt.Sprintf("(%d)", len(amua.knownMaildirs[i].maildir.messages))
availableWidth := w - space - len(nrMsgs) - 3
strfmt := fmt.Sprintf(" %%-%ds %s ", availableWidth, nrMsgs)
str := fmt.Sprintf(strfmt, util.TruncateString(amua.knownMaildirs[i].path, availableWidth))
if current {
colorstring.Fprintf(v, "[bold]%s", str)
} else {
fmt.Fprint(v, str)
}
fmt.Fprintf(v, strings.Repeat(" ", space-1))
fmt.Fprintln(v, "|")
}
for i := 0; i < fillers; i++ {
fmt.Fprintf(v, strings.Repeat(" ", w-1))
fmt.Fprintln(v, "|")
}
return nil
}
// Outputs the board as a string that kinda sorta looks like a tetris board.
func (b *Board) String() string {
var out string = " ┌"
out += strings.Repeat("─", b.width)
out += "┐\n"
for row := 0; row < b.height; row++ {
r := strconv.Itoa(row)
out += r
if row < 10 {
out += " "
}
out += "│"
for col := 0; col < b.width; col++ {
if b.data[row][col] {
out += "X"
} else {
out += " "
}
}
out += "│\n"
}
out += " └"
out += strings.Repeat("─", b.width)
out += "┘\n"
out += " "
for i := 0; i < b.width; i++ {
r := strconv.Itoa(i)
out += r
}
out += "\n"
return out
}
func TestWritePubring(t *testing.T) {
f, err := os.Create("pubring.mix")
if err != nil {
t.Fatal(err)
}
defer f.Close()
var options string
for n := 0; n < 10; n++ {
counter := fmt.Sprintf("%02d", n)
keyid := strings.Repeat("0", 32-len(counter)) + counter
key := strings.Repeat("0", 32) + keyid
if n < 4 {
options = "E"
} else {
options = "M"
}
header := fmt.Sprintf(
"test%02d test%[email protected] %s 4:0.2a %s 2016-01-01 2100-12-31\n\n",
n,
n,
keyid,
options,
)
f.WriteString(header)
f.WriteString("-----Begin Mix Key-----\n")
f.WriteString(keyid + "\n")
f.WriteString(key + "\n")
f.WriteString("-----End Mix Key-----\n\n")
}
}
func (pb *ProgressBar) printToTerminal(printTo io.Writer, numColumns int, padding bool, maxBefore, maxAfter int) {
pb.lock.Lock()
before := pb.printBefore
after := pb.printAfter
if padding {
before = before + strings.Repeat(" ", maxBefore-len(before))
after = strings.Repeat(" ", maxAfter-len(after)) + after
}
progressBarSize := numColumns - (len(fmt.Sprintf("%s [] %s", before, after)))
progressBar := ""
if progressBarSize > 0 {
currentProgress := int(pb.currentProgress * float64(progressBarSize))
progressBar = fmt.Sprintf("[%s%s] ",
strings.Repeat("=", currentProgress),
strings.Repeat(" ", progressBarSize-currentProgress))
} else {
// If we can't fit the progress bar, better to not pad the before/after.
before = pb.printBefore
after = pb.printAfter
}
fmt.Fprintf(printTo, "%s %s%s\n", before, progressBar, after)
pb.lock.Unlock()
}
func DrawBox(x, y, width, height int) {
DrawText(x, y, TOPLEFT+strings.Repeat(HORIZONTAL, width+2)+TOPRIGHT)
for i := 1; i < height+1; i++ {
DrawText(x, y+i, VERTICAL+strings.Repeat(" ", width+2)+VERTICAL)
}
DrawText(x, y+height, BOTTOMLEFT+strings.Repeat(HORIZONTAL, width+2)+BOTTOMRIGHT)
}
func TestDb_GetFromFrozen(t *testing.T) {
h := newDbHarnessWopt(t, &opt.Options{WriteBuffer: 100100})
defer h.close()
h.put("foo", "v1")
h.getVal("foo", "v1")
h.stor.DelaySync(storage.TypeTable) // Block sync calls
h.put("k1", strings.Repeat("x", 100000)) // Fill memtable
h.put("k2", strings.Repeat("y", 100000)) // Trigger compaction
for i := 0; h.db.getFrozenMem() == nil && i < 100; i++ {
time.Sleep(10 * time.Microsecond)
}
if h.db.getFrozenMem() == nil {
h.stor.ReleaseSync(storage.TypeTable)
t.Fatal("No frozen mem")
}
h.getVal("foo", "v1")
h.stor.ReleaseSync(storage.TypeTable) // Release sync calls
h.reopenDB()
h.getVal("foo", "v1")
h.get("k1", true)
h.get("k2", true)
}
func summarize(good int) {
last_10 := math.Max(0, float64(good-50))
first_50 := (math.Min(0, float64(good-50)) + 50) / 10
fmt.Printf("|%s%s%s%s| %d\n", strings.Repeat("#", int(first_50)), strings.Repeat(".", 5-int(first_50)), strings.Repeat("%", int(last_10)), strings.Repeat(".", 10-int(last_10)), good)
}
// PrintRunningStepFooter ..
func PrintRunningStepFooter(stepRunResult models.StepRunResultsModel, isLastStepInWorkflow bool) {
iconBoxWidth := len(" ")
timeBoxWidth := len(" time (s) ")
titleBoxWidth := stepRunSummaryBoxWidthInChars - 4 - iconBoxWidth - timeBoxWidth
sep := fmt.Sprintf("+%s+%s+%s+", strings.Repeat("-", iconBoxWidth), strings.Repeat("-", titleBoxWidth), strings.Repeat("-", timeBoxWidth))
fmt.Println("|" + strings.Repeat(" ", stepRunSummaryBoxWidthInChars-2) + "|")
fmt.Println(sep)
fmt.Println(getRunningStepFooterMainSection(stepRunResult))
fmt.Println(sep)
if stepRunResult.Error != nil || stepRunResult.StepInfo.GlobalInfo.RemovalDate != "" {
footerSubSection := getRunningStepFooterSubSection(stepRunResult)
if footerSubSection != "" {
fmt.Println(footerSubSection)
fmt.Println(sep)
}
}
if !isLastStepInWorkflow {
fmt.Println()
fmt.Println(strings.Repeat(" ", 42) + "â–¼")
fmt.Println()
}
}
func TestValidateSQSQueueName(t *testing.T) {
validNames := []string{
"valid-name",
"valid02-name",
"Valid-Name1",
"_",
"-",
strings.Repeat("W", 80),
}
for _, v := range validNames {
if errors := validateSQSQueueName(v, "name"); len(errors) > 0 {
t.Fatalf("%q should be a valid SQS queue Name", v)
}
}
invalidNames := []string{
"Here is a name with: colon",
"another * invalid name",
"also $ invalid",
"This . is also %% invalid@!)+(",
"*",
"",
" ",
".",
strings.Repeat("W", 81), // length > 80
}
for _, v := range invalidNames {
if errors := validateSQSQueueName(v, "name"); len(errors) == 0 {
t.Fatalf("%q should be an invalid SQS queue Name", v)
}
}
}
// String returns the string of Decimal.
func (this Decimal) String() string {
this.ensureValid()
unscaledString := strings.TrimLeft(this.integer.String(), "-")
if this.scale == 0 {
return unscaledString
}
pointIndex := len(unscaledString) - this.scale
switch {
case pointIndex < 0:
if this.integer.Sign() == -1 {
return "-0." + strings.Repeat("0", -1*pointIndex) + unscaledString
}
return "0." + strings.Repeat("0", -1*pointIndex) + unscaledString
case pointIndex > 0:
if this.integer.Sign() == -1 {
return "-" + unscaledString[0:pointIndex] + "." + unscaledString[pointIndex:]
}
return unscaledString[0:pointIndex] + "." + unscaledString[pointIndex:]
default: // pointIndex == 0
if this.integer.Sign() == -1 {
return "-0." + unscaledString
}
return "0." + unscaledString
}
}
func BuildSpecReport() (string, bool) {
var s string
ok := len(testingErrors) == 0
if !ok {
s += redColor
for _, error := range testingErrors {
indents := 0
for _, contextStr := range error.Contexts {
s += fmt.Sprintf("%s- %s\n", strings.Repeat(" ", indents), contextStr)
indents++
}
s += fmt.Sprintf("%s %s\n\n", strings.Repeat(" ", indents), error.ItString)
s += fmt.Sprintf("%s\n\t%s\n", error.String, error.ErrorLine)
}
s += resetColors
} else {
s += greenColor
s += fmt.Sprintf("All tests passed. %d examples. 0 failures.\n", testingExamples)
s += resetColors
}
return s, ok
}