//TODO: // * Modify lzhuf.c's Encode() so we don't have to use temp files. // * Handle go errors. func encDec(data []byte, encode bool) []byte { // Create temp files outf, _ := ioutil.TempFile("", "lzhuf") inf, _ := ioutil.TempFile("", "lzhuf") defer func() { outf.Close() os.Remove(outf.Name()) os.Remove(inf.Name()) }() // Copy data to in file io.Copy(inf, bytes.NewBuffer(data)) inf.Sync() inf.Close() // Encode/Decode the inf to outf lzs := C.AllocStruct() var retval C.int if encode { retval = C.Encode(0, C.CString(inf.Name()), C.CString(outf.Name()), lzs, 1) } else { retval = C.Decode(0, C.CString(inf.Name()), C.CString(outf.Name()), lzs, 1) } C.FreeStruct(lzs) if retval < 0 { panic("lzhuf encode/decode error") } // Read the compressed/decompressed data from outf b, _ := ioutil.ReadAll(outf) return b }
func build_config( rules string, c *C) (conf string, cleanup func()) { var fconf, rconf *os.File var err error var conf_test Config fconf, err = ioutil.TempFile("", "") if err != nil { panic(err) } rconf, err = ioutil.TempFile("", "") if err != nil { panic(err) } cleanup = func() { fconf.Close() rconf.Close() } // Trailing \n is required by go-config issue #3. fconf.WriteString( "[Settings]\nloglevel=debug\nrules=" + rconf.Name() + "\n") fconf.Sync() rconf.WriteString(rules + "\n") rconf.Sync() conf_test, err = NewFileConfig(fconf.Name()) c.Assert(conf_test, Not(Equals), nil) c.Assert(err, Equals, nil) conf = fconf.Name() return }
func TestConflictingCurrentContext(t *testing.T) { commandLineFile, _ := ioutil.TempFile("", "") defer os.Remove(commandLineFile.Name()) envVarFile, _ := ioutil.TempFile("", "") defer os.Remove(envVarFile.Name()) mockCommandLineConfig := clientcmdapi.Config{ CurrentContext: "any-context-value", } mockEnvVarConfig := clientcmdapi.Config{ CurrentContext: "a-different-context", } WriteToFile(mockCommandLineConfig, commandLineFile.Name()) WriteToFile(mockEnvVarConfig, envVarFile.Name()) loadingRules := ClientConfigLoadingRules{ CommandLinePath: commandLineFile.Name(), EnvVarPath: envVarFile.Name(), } mergedConfig, err := loadingRules.Load() if err != nil { t.Errorf("Unexpected error: %v", err) } if mergedConfig.CurrentContext != mockCommandLineConfig.CurrentContext { t.Errorf("expected %v, got %v", mockCommandLineConfig.CurrentContext, mergedConfig.CurrentContext) } }
func TestSameConfigFalse(t *testing.T) { log.SetLevel("warn") src, err := ioutil.TempFile("", "src") defer os.Remove(src.Name()) if err != nil { t.Errorf(err.Error()) } _, err = src.WriteString("src") if err != nil { t.Errorf(err.Error()) } dest, err := ioutil.TempFile("", "dest") defer os.Remove(dest.Name()) if err != nil { t.Errorf(err.Error()) } _, err = dest.WriteString("dest") if err != nil { t.Errorf(err.Error()) } status, err := sameConfig(src.Name(), dest.Name()) if err != nil { t.Errorf(err.Error()) } if status != false { t.Errorf("Expected sameConfig(src, dest) to be %v, got %v", false, status) } }
func TestMigratingFile(t *testing.T) { sourceFile, _ := ioutil.TempFile("", "") defer os.Remove(sourceFile.Name()) destinationFile, _ := ioutil.TempFile("", "") // delete the file so that we'll write to it os.Remove(destinationFile.Name()) WriteToFile(testConfigAlfa, sourceFile.Name()) loadingRules := ClientConfigLoadingRules{ MigrationRules: map[string]string{destinationFile.Name(): sourceFile.Name()}, } if _, err := loadingRules.Load(); err != nil { t.Errorf("unexpected error %v", err) } // the load should have recreated this file defer os.Remove(destinationFile.Name()) sourceContent, err := ioutil.ReadFile(sourceFile.Name()) if err != nil { t.Errorf("unexpected error %v", err) } destinationContent, err := ioutil.ReadFile(destinationFile.Name()) if err != nil { t.Errorf("unexpected error %v", err) } if !reflect.DeepEqual(sourceContent, destinationContent) { t.Errorf("source and destination do not match") } }
func TestProvisionerPrepare_Defaults(t *testing.T) { var p Provisioner config := testConfig() err := p.Prepare(config) if err == nil { t.Fatalf("should have error") } hostkey_file, err := ioutil.TempFile("", "hostkey") if err != nil { t.Fatalf("err: %s", err) } defer os.Remove(hostkey_file.Name()) publickey_file, err := ioutil.TempFile("", "publickey") if err != nil { t.Fatalf("err: %s", err) } defer os.Remove(publickey_file.Name()) playbook_file, err := ioutil.TempFile("", "playbook") if err != nil { t.Fatalf("err: %s", err) } defer os.Remove(playbook_file.Name()) config["ssh_host_key_file"] = hostkey_file.Name() config["ssh_authorized_key_file"] = publickey_file.Name() config["playbook_file"] = playbook_file.Name() err = p.Prepare(config) if err != nil { t.Fatalf("err: %s", err) } }
func (t *FileConfigTest) TestLoadsRelativeRulesPath(c *C) { var fconf, rconf *os.File var err error var conf Config fconf, err = ioutil.TempFile("", "") if err != nil { panic(err) } rconf, err = ioutil.TempFile("", "") if err != nil { panic(err) } defer (func() { fconf.Close() rconf.Close() })() path, _ := filepath.Rel(filepath.Dir(fconf.Name()), rconf.Name()) // Trailing \n is required by go-config issue #3. fconf.WriteString("[Settings]\nloglevel=debug\nrules=" + path + "\n") fconf.Sync() conf, err = NewFileConfig(fconf.Name()) c.Assert(conf, Not(Equals), nil) c.Assert(err, Equals, nil) }
func createTestCertFiles(dir string, spec TestCertSpec) (certFilePath, keyFilePath string, err error) { certPem, keyPem, err := utilcert.GenerateSelfSignedCertKey(spec.host, parseIPList(spec.ips), spec.names) if err != nil { return "", "", err } certFile, err := ioutil.TempFile(dir, "cert") if err != nil { return "", "", err } keyFile, err := ioutil.TempFile(dir, "key") if err != nil { return "", "", err } _, err = certFile.Write(certPem) if err != nil { return "", "", err } certFile.Close() _, err = keyFile.Write(keyPem) if err != nil { return "", "", err } keyFile.Close() return certFile.Name(), keyFile.Name(), nil }
func TestMinifySuccess(t *testing.T) { certFile, _ := ioutil.TempFile("", "") defer os.Remove(certFile.Name()) keyFile, _ := ioutil.TempFile("", "") defer os.Remove(keyFile.Name()) caFile, _ := ioutil.TempFile("", "") defer os.Remove(caFile.Name()) mutatingConfig := newMergedConfig(certFile.Name(), "cert", keyFile.Name(), "key", caFile.Name(), "ca", t) if err := MinifyConfig(&mutatingConfig); err != nil { t.Errorf("unexpected error: %v", err) } if len(mutatingConfig.Contexts) > 1 { t.Errorf("unexpected contexts: %v", mutatingConfig.Contexts) } if _, exists := mutatingConfig.Contexts["federal-context"]; !exists { t.Errorf("missing context") } if len(mutatingConfig.Clusters) > 1 { t.Errorf("unexpected clusters: %v", mutatingConfig.Clusters) } if _, exists := mutatingConfig.Clusters["cow-cluster"]; !exists { t.Errorf("missing cluster") } if len(mutatingConfig.AuthInfos) > 1 { t.Errorf("unexpected users: %v", mutatingConfig.AuthInfos) } if _, exists := mutatingConfig.AuthInfos["red-user"]; !exists { t.Errorf("missing user") } }
// DumpLogs dumps logs from a Backup/Restore/Import/Export job to the console func (d *SDb) DumpLogs(taskType string, job *models.Job, service *models.Service) error { logrus.Printf("Retrieving %s logs for job %s...", service.Label, job.ID) tempURL, err := d.TempLogsURL(job.ID, service.ID) if err != nil { return err } dir, err := ioutil.TempDir("", "") if err != nil { return err } encrFile, err := ioutil.TempFile(dir, "") if err != nil { return err } resp, err := http.Get(tempURL.URL) if err != nil { return err } defer resp.Body.Close() io.Copy(encrFile, resp.Body) encrFile.Close() plainFile, err := ioutil.TempFile(dir, "") if err != nil { return err } // do we have to close this before calling DecryptFile? // or can two processes have a file open simultaneously? plainFile.Close() if taskType == "backup" { logsKey := job.Backup.KeyLogs if logsKey == "" { logsKey = job.Backup.Key } err := d.Crypto.DecryptFile(encrFile.Name(), logsKey, job.Backup.IV, plainFile.Name()) if err != nil { return err } } else if taskType == "restore" { logsKey := job.Restore.KeyLogs if logsKey == "" { logsKey = job.Restore.Key } err := d.Crypto.DecryptFile(encrFile.Name(), logsKey, job.Restore.IV, plainFile.Name()) if err != nil { return err } } logrus.Printf("-------------------------- Begin %s logs --------------------------", service.Label) plainFile, _ = os.Open(plainFile.Name()) io.Copy(os.Stdout, plainFile) plainFile.Close() logrus.Printf("--------------------------- End %s logs ---------------------------", service.Label) os.Remove(encrFile.Name()) os.Remove(plainFile.Name()) os.Remove(dir) return nil }
func TestExpandInjectedFiles(t *testing.T) { tmp, err := ioutil.TempDir("", "s2i-test-") tmpNested, err := ioutil.TempDir(tmp, "nested") if err != nil { t.Errorf("Unable to create temp directory: %v", err) } defer os.RemoveAll(tmp) list := api.VolumeList{{Source: tmp, Destination: "/foo"}} f1, _ := ioutil.TempFile(tmp, "foo") f2, _ := ioutil.TempFile(tmpNested, "bar") files, err := ExpandInjectedFiles(list) if err != nil { t.Errorf("Unexpected error: %v", err) } expected := []string{"/foo/" + filepath.Base(f1.Name()), filepath.Join("/foo", filepath.Base(tmpNested), filepath.Base(f2.Name()))} for _, exp := range expected { found := false for _, f := range files { if f == exp { found = true } } if !found { t.Errorf("Expected %q in resulting file list, got %+v", exp, files) } } }
// Bundle stuff... // BUG(echu): need to figure out how to handle conflicts in bundle names func (ctx *Context) Bundle(bundlePath string) error { log.Printf("==> Creating bundle from '%s'", bundlePath) defer log.Printf("<== Bundling complete.") log.Printf(" | Parsing bundle config.") bundleConfig, err := ParseBundleFromDir(bundlePath) if err != nil { return err } log.Printf(" %v", bundleConfig) log.Printf(" | Making temp file for python wrapper") wrapper, err := ioutil.TempFile(bundlePath, "plumber") defer removeTempFile(wrapper) if err != nil { return err } log.Printf(" Created '%s'", wrapper.Name()) templateCtx := templateContext{ Wrapper: path.Base(wrapper.Name()), Plumber: bundleConfig, } log.Printf(" | Writing wrapper.") tmpl, err := template.New("wrapper").Parse(wrapperTemplate) if err != nil { return err } if err := tmpl.Execute(wrapper, templateCtx); err != nil { return err } log.Printf(" Done.") log.Printf(" | Making temp file for Dockerfile") dockerfile, err := ioutil.TempFile(bundlePath, "plumber") defer removeTempFile(dockerfile) if err != nil { return err } log.Printf(" Created '%s'", dockerfile.Name()) log.Printf(" | Writing Dockerfile.") tmpl, err = template.New("dockerfile").Parse(dockerfileTemplate) if err != nil { return err } if err := tmpl.Execute(dockerfile, templateCtx); err != nil { return err } log.Printf(" Done.") log.Printf(" | Building container.") err = shell.RunAndLog(ctx.DockerCmd, "build", "--pull", "-t", ctx.GetImage(bundleConfig.Name), "-f", dockerfile.Name(), bundlePath) if err != nil { return err } log.Printf(" Container '%s' built.", ctx.GetImage(bundleConfig.Name)) return nil }
func makeFineDmndDB(seqBuf *bytes.Buffer) (string, error) { tmpSeqFile, err := ioutil.TempFile(".", "fine-sequences-") if err != nil { return "", fmt.Errorf("Could not create temporary sequence file: %s\n", err) } err = ioutil.WriteFile(tmpSeqFile.Name(), seqBuf.Bytes(), 0666) if err != nil { return "", fmt.Errorf("Could not write to temporary sequence file: %s\n", err) } tmpDmndFile, err := ioutil.TempFile(".", "fine-dmnd-db-") if err != nil { return "", fmt.Errorf("Could not create temporary diamond file: %s\n", err) } cmd := exec.Command( flagDmnd, "makedb", "--in", tmpSeqFile.Name(), "-d", tmpDmndFile.Name()) err = mica.Exec(cmd) if err != nil { return "", fmt.Errorf("Could not create fine diamond database: %s\n", err) } err = os.RemoveAll(tmpSeqFile.Name()) if err != nil { return "", fmt.Errorf("Could not remove temporary sequence file: %s\n", err) } return tmpDmndFile.Name(), nil }
// VerifyDetachedSignature verifies combination of signature and cleartext using gpgv func (g *GpgVerifier) VerifyDetachedSignature(signature, cleartext io.Reader) error { args := g.argsKeyrings() sigf, err := ioutil.TempFile("", "aptly-gpg") if err != nil { return err } defer os.Remove(sigf.Name()) defer sigf.Close() _, err = io.Copy(sigf, signature) if err != nil { return err } clearf, err := ioutil.TempFile("", "aptly-gpg") if err != nil { return err } defer os.Remove(clearf.Name()) defer clearf.Close() _, err = io.Copy(clearf, cleartext) if err != nil { return err } args = append(args, sigf.Name(), clearf.Name()) return g.runGpgv(args, "detached signature") }
func helpDiff(a, b string) (string, error) { atmp, err := ioutil.TempFile("", "help-diff") if err != nil { return "", err } btmp, err := ioutil.TempFile("", "help-diff") if err != nil { return "", err } if _, err := io.WriteString(atmp, a); err != nil { return "", err } if _, err := io.WriteString(btmp, b); err != nil { return "", err } ret, err := exec.Command("diff", "-u", "-d", "--label", "got", atmp.Name(), "--label", "expected", btmp.Name()).Output() os.Remove(atmp.Name()) os.Remove(btmp.Name()) if err.Error() == "exit status 1" { return string(ret), nil } return string(ret), err }
func TestThumbnail(t *testing.T) { input, err := ioutil.TempFile("", "") if err != nil { t.Fatal(err) } defer os.Remove(input.Name()) input.Write(sourceInput) input.Close() output, err := ioutil.TempFile("", "") if err != nil { t.Fatal(err) } defer os.Remove(output.Name()) output.Close() err = Thumbnail(input.Name(), output.Name(), 4, 75, ScaleTypeFitMin) if err != nil { t.Fatal(err) } bytes, err := ioutil.ReadFile(output.Name()) if err != nil { t.Fatal(err) } if !reflect.DeepEqual(bytes, thumbnailOutput) { t.Errorf("Thumbnail failed") } }
func (interceptor *outputInterceptor) StartInterceptingOutput() error { if interceptor.intercepting { return errors.New("Already intercepting output!") } interceptor.intercepting = true var err error interceptor.redirectFile, err = ioutil.TempFile("", "ginkgo") if err != nil { return err } interceptor.stdoutPlaceholder, err = ioutil.TempFile("", "ginkgo") if err != nil { return err } interceptor.stderrPlaceholder, err = ioutil.TempFile("", "ginkgo") if err != nil { return err } syscall.Dup2(1, int(interceptor.stdoutPlaceholder.Fd())) syscall.Dup2(2, int(interceptor.stderrPlaceholder.Fd())) syscall.Dup2(int(interceptor.redirectFile.Fd()), 1) syscall.Dup2(int(interceptor.redirectFile.Fd()), 2) return nil }
func TestTransform(t *testing.T) { input, err := ioutil.TempFile("", "") if err != nil { t.Fatal(err) } defer os.Remove(input.Name()) input.Write(sourceInput) input.Close() output, err := ioutil.TempFile("", "") if err != nil { t.Fatal(err) } defer os.Remove(output.Name()) output.Close() err = Transform(input.Name(), output.Name(), TransformTransverse) if err != nil { t.Fatal(err) } bytes, err := ioutil.ReadFile(output.Name()) if err != nil { t.Fatal(err) } if !reflect.DeepEqual(bytes, transformOutput) { t.Errorf("TestTransform failed") } }
func load_config( config string, rules string, c *C) (conf *FileConfig, cleanup func()) { var fconf, rconf *os.File var err error fconf, err = ioutil.TempFile("", "") if err != nil { panic(err) } rconf, err = ioutil.TempFile("", "") if err != nil { panic(err) } cleanup = func() { fconf.Close() rconf.Close() } // Trailing \n is required by go-config issue #3. fconf.WriteString( "[Settings]\n" + config + "\n" + "rules=" + rconf.Name() + "\n") fconf.Sync() rconf.WriteString(rules + "\n") rconf.Sync() conf, err = NewFileConfig(fconf.Name()) c.Assert(conf, Not(Equals), nil) c.Assert(err, Equals, nil) return }
func TestFileLogger(t *testing.T) { tmpDir, err := ioutil.TempDir("", "_gnatsd") if err != nil { t.Fatal("Could not create tmp dir") } defer os.RemoveAll(tmpDir) file, err := ioutil.TempFile(tmpDir, "gnatsd:log_") if err != nil { t.Fatalf("Could not create the temp file: %v", err) } file.Close() logger := NewFileLogger(file.Name(), false, false, false, false) logger.Noticef("foo") buf, err := ioutil.ReadFile(file.Name()) if err != nil { t.Fatalf("Could not read logfile: %v", err) } if len(buf) <= 0 { t.Fatal("Expected a non-zero length logfile") } if string(buf) != "[INF] foo\n" { t.Fatalf("Expected '%s', received '%s'\n", "[INFO] foo", string(buf)) } file, err = ioutil.TempFile(tmpDir, "gnatsd:log_") if err != nil { t.Fatalf("Could not create the temp file: %v", err) } file.Close() logger = NewFileLogger(file.Name(), true, true, true, true) logger.Errorf("foo") buf, err = ioutil.ReadFile(file.Name()) if err != nil { t.Fatalf("Could not read logfile: %v", err) } if len(buf) <= 0 { t.Fatal("Expected a non-zero length logfile") } str := string(buf) errMsg := fmt.Sprintf("Expected '%s', received '%s'\n", "[pid] <date> [ERR] foo", str) pidEnd := strings.Index(str, " ") infoStart := strings.LastIndex(str, "[ERR]") if pidEnd == -1 || infoStart == -1 { t.Fatalf("%v", errMsg) } pid := str[0:pidEnd] if pid[0] != '[' || pid[len(pid)-1] != ']' { t.Fatalf("%v", errMsg) } //TODO: Parse date. if !strings.HasSuffix(str, "[ERR] foo\n") { t.Fatalf("%v", errMsg) } }
func (t *FileConfigTest) TestRulesFileDoesNotExist(c *C) { var fconf, rconf *os.File var err error var conf Config fconf, err = ioutil.TempFile("", "") if err != nil { panic(err) } rconf, err = ioutil.TempFile("", "") if err != nil { panic(err) } defer (func() { fconf.Close() rconf.Close() })() // Trailing \n is required by go-config issue #3. fconf.WriteString("[Settings]\nloglevel=debug\nrules=\n") fconf.Sync() conf, err = NewFileConfig(fconf.Name()) c.Check(conf, Equals, (*FileConfig)(nil)) c.Check(err, Not(Equals), nil) }
func benchmarkCopyDown(b *testing.B, fileSize int64, delay time.Duration) { // Create a temp file and fill it with zero's. src, err := ioutil.TempFile("", "sftptest") if err != nil { b.Fatal(err) } defer src.Close() srcFilename := src.Name() defer os.Remove(srcFilename) zero, err := os.Open("/dev/zero") if err != nil { b.Fatal(err) } n, err := io.Copy(src, io.LimitReader(zero, fileSize)) if err != nil { b.Fatal(err) } if n < fileSize { b.Fatal("short copy") } zero.Close() src.Close() sftp, cmd := testClient(b, READONLY, delay) defer cmd.Wait() defer sftp.Close() b.ResetTimer() b.SetBytes(fileSize) for i := 0; i < b.N; i++ { dst, err := ioutil.TempFile("", "sftptest") if err != nil { b.Fatal(err) } defer os.Remove(dst.Name()) src, err := sftp.Open(srcFilename) if err != nil { b.Fatal(err) } defer src.Close() n, err := io.Copy(dst, src) if err != nil { b.Fatalf("copy error: %v", err) } if n < fileSize { b.Fatal("unable to copy all bytes") } dst.Close() fi, err := os.Stat(dst.Name()) if err != nil { b.Fatal(err) } if fi.Size() != fileSize { b.Fatalf("wrong file size: want %d, got %d", fileSize, fi.Size()) } os.Remove(dst.Name()) } }
// testEventScript creates an event script that can be used with the // agent. It returns the path to the event script itself and a path to // the file that will contain the events that that script receives. func testEventScript(t *testing.T, script string) (string, string) { scriptFile, err := ioutil.TempFile("", "serf") if err != nil { t.Fatalf("err: %s", err) } defer scriptFile.Close() if err := scriptFile.Chmod(0755); err != nil { t.Fatalf("err: %s", err) } resultFile, err := ioutil.TempFile("", "serf-result") if err != nil { t.Fatalf("err: %s", err) } defer resultFile.Close() _, err = scriptFile.Write([]byte( fmt.Sprintf(script, resultFile.Name()))) if err != nil { t.Fatalf("err: %s") } return scriptFile.Name(), resultFile.Name() }
func sign(xml string, privateKeyPath string, id string) (string, error) { samlXmlsecInput, err := ioutil.TempFile(os.TempDir(), "tmpgs") if err != nil { return "", err } defer deleteTempFile(samlXmlsecInput.Name()) samlXmlsecInput.WriteString("<?xml version='1.0' encoding='UTF-8'?>\n") samlXmlsecInput.WriteString(xml) samlXmlsecInput.Close() samlXmlsecOutput, err := ioutil.TempFile(os.TempDir(), "tmpgs") if err != nil { return "", err } defer deleteTempFile(samlXmlsecOutput.Name()) samlXmlsecOutput.Close() // fmt.Println("xmlsec1", "--sign", "--privkey-pem", privateKeyPath, // "--id-attr:ID", id, // "--output", samlXmlsecOutput.Name(), samlXmlsecInput.Name()) output, err := exec.Command("xmlsec1", "--sign", "--privkey-pem", privateKeyPath, "--id-attr:ID", id, "--output", samlXmlsecOutput.Name(), samlXmlsecInput.Name()).CombinedOutput() if err != nil { return "", errors.New(err.Error() + " : " + string(output)) } samlSignedRequest, err := ioutil.ReadFile(samlXmlsecOutput.Name()) if err != nil { return "", err } samlSignedRequestXML := strings.Trim(string(samlSignedRequest), "\n") return samlSignedRequestXML, nil }
func TestMigratingFileLeaveExistingFileAlone(t *testing.T) { sourceFile, _ := ioutil.TempFile("", "") defer os.Remove(sourceFile.Name()) destinationFile, _ := ioutil.TempFile("", "") defer os.Remove(destinationFile.Name()) WriteToFile(testConfigAlfa, sourceFile.Name()) loadingRules := ClientConfigLoadingRules{ MigrationRules: map[string]string{destinationFile.Name(): sourceFile.Name()}, } if _, err := loadingRules.Load(); err != nil { t.Errorf("unexpected error %v", err) } destinationContent, err := ioutil.ReadFile(destinationFile.Name()) if err != nil { t.Errorf("unexpected error %v", err) } if len(destinationContent) > 0 { t.Errorf("destination should not have been touched") } }
func TestSearchExist(t *testing.T) { t.Parallel() nodes, _ := ioutil.TempFile(os.TempDir(), "bplus_search_test") defer os.Remove(nodes.Name()) values, _ := ioutil.TempFile(os.TempDir(), "bplus_search_test") defer os.Remove(values.Name()) var invalid, val BPlusValue invalid = append(invalid, []byte("INVALID INVALID BACON INVALID")...) val = append(val, []byte("This is a valid value.")...) for i := 0; i < 5; i++ { Insert(nodes, values, BPlusKey(i), invalid) } Insert(nodes, values, 5, val) for i := 6; i < 10; i++ { Insert(nodes, values, BPlusKey(i), invalid) } found := Search(nodes, values, 5) if found == nil { t.Error("found == nil") } if !found.Equal(val) { t.Log("found ", found) t.Log("wanted ", val) t.Fail() } }
func diff(b1, b2 []byte) (data []byte, err error) { f1, err := ioutil.TempFile("", "gofmt") if err != nil { return } defer os.Remove(f1.Name()) defer f1.Close() f2, err := ioutil.TempFile("", "gofmt") if err != nil { return } defer os.Remove(f2.Name()) defer f2.Close() f1.Write(b1) f2.Write(b2) data, err = exec.Command("diff", "-u", f1.Name(), f2.Name()).CombinedOutput() if len(data) > 0 { // diff exits with a non-zero status when the files don't match. // Ignore that failure as long as we get output. err = nil } return }
func BenchmarkGetAll(b *testing.B) { b.StopTimer() nodes, _ := ioutil.TempFile(os.TempDir(), "bplus_search_benchmark") defer os.Remove(nodes.Name()) values, _ := ioutil.TempFile(os.TempDir(), "bplus_search_benchmark") defer os.Remove(values.Name()) var val BPlusValue val = append(val, []byte("Test123")...) for i := 0; i < 1000; i++ { Insert(nodes, values, BPlusKey(i), val) } b.StartTimer() // One iteration of BenchmarkGetAll = one Search call in BenchmarkSearch. This is done so the values are comparable. for i := 0; i < b.N/1000+1; i++ { for it := GetAll(nodes, values); it.Valid(); it.Next() { it.Value() } } }
func (l *darwinLauncher) Launch(address string, region *lol.Region, id lol.GameID, encryptionKey string) error { cmd := exec.Command(l.launcherPath, MaestroParam1, MaestroParam2, l.clientPath, fmt.Sprintf(`spectator %s %s %d %s`, address, encryptionKey, id, region.PlatformID())) cmd.Dir = path.Dir(l.launcherPath) cmd.Env = append(os.Environ(), "riot_launched=true") now := time.Now() debugErr, err := ioutil.TempFile("", fmt.Sprintf("go-lol-client-debug-stderr-%d.txt", now.Unix())) if err != nil { return err } defer debugErr.Close() debugOut, err := ioutil.TempFile("", fmt.Sprintf("go-lol-client-debug-stdout-%d.txt", now.Unix())) if err != nil { return err } defer debugOut.Close() log.Printf("Connecting client output to %s and %s", debugErr.Name(), debugOut.Name()) cmd.Stdout = debugOut cmd.Stderr = debugErr return cmd.Run() }
func Diff(old, new string) []byte { f1, err := ioutil.TempFile("", "go-fix") if err != nil { return []byte(fmt.Sprintf("writing temp file: %v\n", err)) } defer os.Remove(f1.Name()) defer f1.Close() f2, err := ioutil.TempFile("", "go-fix") if err != nil { return []byte(fmt.Sprintf("writing temp file: %v\n", err)) } defer os.Remove(f2.Name()) defer f2.Close() f1.Write([]byte(old)) f2.Write([]byte(new)) // Use git diff to get consistent output and also for the context after @@ lines. data, err := exec.Command("git", "diff", f1.Name(), f2.Name()).CombinedOutput() if len(data) > 0 { // diff exits with a non-zero status when the files don't match. // Ignore that failure as long as we get output. err = nil } if err != nil { return []byte(fmt.Sprintf("invoking git diff: %v\n%s", err, data)) } // skip over diff header, since it is showing temporary file names i := bytes.Index(data, []byte("\n@@")) if i >= 0 { data = data[i+1:] } return data }