How to use Close method of isolated Package

Best Syzkaller code snippet using isolated.Close

isolatedfake.go

Source:isolatedfake.go

...117		if r.Header.Get("Content-Type") != contentType {118			s.fail(fmt.Errorf("invalid content type: %q", r.Header.Get("Content-Type")))119			return120		}121		defer r.Body.Close()122		out := handler(r)123		w.Header().Set("Content-Type", contentType)124		j := json.NewEncoder(w)125		if err := j.Encode(out); err != nil {126			s.fail(err)127		}128	})129	s.Handle(path, h)130}131func (s *IsolatedFake) serverDetails(r *http.Request) interface{} {132	content, err := ioutil.ReadAll(r.Body)133	if err != nil {134		s.fail(err)135	}136	if string(content) != "{}" {137		s.fail(fmt.Errorf("unexpected content %#v", string(content)))138	}139	return map[string]string{"server_version": "v1"}140}141func (s *IsolatedFake) preupload(r *http.Request) interface{} {142	data := &isolateservice.HandlersEndpointsV1DigestCollection{}143	if err := json.NewDecoder(r.Body).Decode(data); err != nil {144		s.fail(err)145	}146	if data.Namespace == nil {147		s.fail(fmt.Errorf("unexpected namespace %#v", data.Namespace.Namespace))148	}149	out := &isolateservice.HandlersEndpointsV1UrlCollection{}150	namespace := data.Namespace.Namespace151	s.mu.Lock()152	defer s.mu.Unlock()153	for i, d := range data.Items {154		if _, ok := s.contents[namespace]; !ok {155			s.contents[namespace] = map[isolated.HexDigest][]byte{}156		}157		if _, ok := s.contents[namespace][isolated.HexDigest(d.Digest)]; !ok {158			// Simulate a write to Cloud Storage for larger writes.159			s := &isolateservice.HandlersEndpointsV1PreuploadStatus{160				Index:        int64(i),161				UploadTicket: "ticket:" + namespace + "," + string(d.Digest),162			}163			if d.Size > 1024 {164				s.GsUploadUrl = gsURLWithDigestQuery(r.Host, "upload", namespace, d.Digest).String()165			}166			out.Items = append(out.Items, s)167		}168	}169	return out170}171func (s *IsolatedFake) fakeCloudStorageUpload(w http.ResponseWriter, r *http.Request) {172	defer r.Body.Close()173	if r.Header.Get("Content-Type") != "application/octet-stream" {174		w.WriteHeader(400)175		s.fail(fmt.Errorf("invalid content type: %q", r.Header.Get("Content-Type")))176		return177	}178	if r.Method != "PUT" {179		w.WriteHeader(405)180		s.fail(fmt.Errorf("invalid method: %q", r.Method))181		return182	}183	namespace := r.URL.Query().Get("namespace")184	if namespace == "" {185		w.WriteHeader(400)186		s.fail(fmt.Errorf("missing namespace"))187		return188	}189	decompressor, err := isolated.GetDecompressor(namespace, r.Body)190	if err != nil {191		w.WriteHeader(500)192		s.fail(err)193		return194	}195	defer decompressor.Close()196	raw, err := ioutil.ReadAll(decompressor)197	if err != nil {198		w.WriteHeader(500)199		s.fail(err)200		return201	}202	digest := isolated.HexDigest(r.URL.Query().Get("digest"))203	if digest != isolated.HashBytes(isolated.GetHash(namespace), raw) {204		w.WriteHeader(400)205		s.fail(fmt.Errorf("invalid digest %#v", digest))206		return207	}208	s.mu.Lock()209	defer s.mu.Unlock()210	if _, ok := s.staging[namespace]; !ok {211		s.staging[namespace] = map[isolated.HexDigest][]byte{}212	}213	s.staging[namespace][digest] = raw214	w.WriteHeader(200)215}216func (s *IsolatedFake) fakeCloudStorageDownload(w http.ResponseWriter, r *http.Request) {217	defer r.Body.Close()218	if r.Method != "GET" {219		w.WriteHeader(405)220		s.fail(fmt.Errorf("invalid method: %q", r.Method))221		return222	}223	namespace := r.URL.Query().Get("namespace")224	store, ok := s.contents[namespace]225	if !ok {226		w.WriteHeader(404)227		s.fail(fmt.Errorf("namespace not found: %q", namespace))228		return229	}230	digest := isolated.HexDigest(r.URL.Query().Get("digest"))231	data, ok := store[digest]232	if !ok {233		w.WriteHeader(404)234		s.fail(fmt.Errorf("file not found: %q", digest))235		return236	}237	var buf bytes.Buffer238	compressor, err := isolated.GetCompressor(namespace, &buf)239	if err != nil {240		w.WriteHeader(500)241		s.fail(err)242		return243	}244	if _, err := io.CopyBuffer(compressor, bytes.NewReader(data), nil); err != nil {245		compressor.Close()246		w.WriteHeader(500)247		s.fail(err)248		return249	}250	if err := compressor.Close(); err != nil {251		w.WriteHeader(500)252		s.fail(err)253		return254	}255	w.Write(buf.Bytes())256}257func (s *IsolatedFake) finalizeGSUpload(r *http.Request) interface{} {258	data := &isolateservice.HandlersEndpointsV1FinalizeRequest{}259	if err := json.NewDecoder(r.Body).Decode(data); err != nil {260		s.fail(err)261		return map[string]string{"err": err.Error()}262	}263	prefix := "ticket:"264	if !strings.HasPrefix(data.UploadTicket, prefix) {265		err := fmt.Errorf("unexpected ticket %#v", data.UploadTicket)266		s.fail(err)267		return map[string]string{"err": err.Error()}268	}269	parts := strings.SplitN(data.UploadTicket[len(prefix):], ",", 2)270	if len(parts) != 2 {271		err := fmt.Errorf("unexpected ticket %#v", data.UploadTicket)272		s.fail(err)273		return map[string]string{"err": err.Error()}274	}275	namespace := parts[0]276	digest := isolated.HexDigest(parts[1])277	if !digest.Validate(isolated.GetHash(namespace)) {278		err := fmt.Errorf("invalid digest %#v", digest)279		s.fail(err)280		return map[string]string{"err": err.Error()}281	}282	s.mu.Lock()283	defer s.mu.Unlock()284	if _, ok := s.staging[namespace]; !ok {285		err := fmt.Errorf("finalizing non uploaded file in unknown namespace")286		s.failLocked(err)287		return map[string]string{"err": err.Error()}288	}289	if _, ok := s.staging[namespace][digest]; !ok {290		err := fmt.Errorf("finalizing non uploaded file")291		s.failLocked(err)292		return map[string]string{"err": err.Error()}293	}294	if _, ok := s.contents[namespace]; !ok {295		s.contents[namespace] = map[isolated.HexDigest][]byte{}296	}297	s.contents[namespace][digest] = s.staging[namespace][digest]298	delete(s.staging[namespace], digest)299	return map[string]string{"ok": "true"}300}301func (s *IsolatedFake) storeInline(r *http.Request) interface{} {302	data := &isolateservice.HandlersEndpointsV1StorageRequest{}303	if err := json.NewDecoder(r.Body).Decode(data); err != nil {304		s.fail(err)305		return map[string]string{"err": err.Error()}306	}307	prefix := "ticket:"308	if !strings.HasPrefix(data.UploadTicket, prefix) {309		err := fmt.Errorf("unexpected ticket %#v", data.UploadTicket)310		s.fail(err)311		return map[string]string{"err": err.Error()}312	}313	parts := strings.SplitN(data.UploadTicket[len(prefix):], ",", 2)314	if len(parts) != 2 {315		err := fmt.Errorf("unexpected ticket %#v", data.UploadTicket)316		s.fail(err)317		return map[string]string{"err": err.Error()}318	}319	namespace := parts[0]320	digest := isolated.HexDigest(parts[1])321	h := isolated.GetHash(namespace)322	if !digest.Validate(h) {323		err := fmt.Errorf("invalid digest %#v", digest)324		s.fail(err)325		return map[string]string{"err": err.Error()}326	}327	blob, err := base64.StdEncoding.DecodeString(data.Content)328	if err != nil {329		s.fail(err)330		return map[string]string{"err": err.Error()}331	}332	decompressor, err := isolated.GetDecompressor(namespace, bytes.NewReader(blob))333	if err != nil {334		s.fail(err)335		return map[string]string{"err": err.Error()}336	}337	defer decompressor.Close()338	raw, err := ioutil.ReadAll(decompressor)339	if err != nil {340		s.fail(err)341		return map[string]string{"err": err.Error()}342	}343	if digest != isolated.HashBytes(h, raw) {344		err := fmt.Errorf("invalid digest %#v", digest)345		s.fail(err)346		return map[string]string{"err": err.Error()}347	}348	s.mu.Lock()349	defer s.mu.Unlock()350	if _, ok := s.contents[namespace]; !ok {351		s.contents[namespace] = map[isolated.HexDigest][]byte{}352	}353	s.contents[namespace][digest] = raw354	return map[string]string{"ok": "true"}355}356func (s *IsolatedFake) retrieve(r *http.Request) interface{} {357	data := &isolateservice.HandlersEndpointsV1RetrieveRequest{}358	if err := json.NewDecoder(r.Body).Decode(data); err != nil {359		s.fail(err)360		return map[string]string{"err": err.Error()}361	}362	digest := isolated.HexDigest(data.Digest)363	namespace := data.Namespace.Namespace364	if _, ok := s.contents[namespace]; !ok {365		err := fmt.Errorf("no such digest %#v", digest)366		s.fail(err)367		return map[string]string{"err": err.Error()}368	}369	rawContent, ok := s.contents[namespace][digest]370	if !ok {371		err := fmt.Errorf("no such digest %#v", digest)372		s.fail(err)373		return map[string]string{"err": err.Error()}374	}375	if len(rawContent) > 1024 {376		return &isolateservice.HandlersEndpointsV1RetrievedContent{377			Url: gsURLWithDigestQuery(r.Host, "download", namespace, data.Digest).String(),378		}379	}380	// Since we decompress when we get the data, we need to recompress when381	// something is fetched.382	var buf bytes.Buffer383	compressor, err := isolated.GetCompressor(namespace, &buf)384	if err != nil {385		s.fail(err)386		return map[string]string{"err": err.Error()}387	}388	if _, err := io.CopyBuffer(compressor, bytes.NewReader(rawContent), nil); err != nil {389		compressor.Close()390		s.fail(err)391		return map[string]string{"err": err.Error()}392	}393	if err := compressor.Close(); err != nil {394		s.fail(err)395		return map[string]string{"err": err.Error()}396	}397	return &isolateservice.HandlersEndpointsV1RetrievedContent{398		Content: base64.StdEncoding.EncodeToString(buf.Bytes()),399	}400}...

isolate_test.go

Source:isolate_test.go

...57	ctx := context.Background()58	Convey(`Tests the creation and archival of an isolate file.`, t, func() {59		server := isolatedfake.New()60		ts := httptest.NewServer(server)61		defer ts.Close()62		a := archiver.New(ctx, isolatedclient.New(nil, nil, ts.URL, isolatedclient.DefaultNamespace, nil, nil), nil)63		// Setup temporary directory.64		//   /base/bar65		//   /base/ignored66		//   /foo/baz.isolate67		//   /link -> /base/bar68		//   /second/boz69		// Result:70		//   /baz.isolated71		tmpDir, err := ioutil.TempDir("", "isolate")72		So(err, ShouldBeNil)73		defer func() {74			if err := os.RemoveAll(tmpDir); err != nil {75				t.Fail()76			}77		}()78		baseDir := filepath.Join(tmpDir, "base")79		fooDir := filepath.Join(tmpDir, "foo")80		secondDir := filepath.Join(tmpDir, "second")81		So(os.Mkdir(baseDir, 0700), ShouldBeNil)82		So(os.Mkdir(fooDir, 0700), ShouldBeNil)83		So(os.Mkdir(secondDir, 0700), ShouldBeNil)84		So(ioutil.WriteFile(filepath.Join(baseDir, "bar"), []byte("foo"), 0600), ShouldBeNil)85		So(ioutil.WriteFile(filepath.Join(baseDir, "ignored"), []byte("ignored"), 0600), ShouldBeNil)86		So(ioutil.WriteFile(filepath.Join(secondDir, "boz"), []byte("foo2"), 0600), ShouldBeNil)87		isolate := `{88		'variables': {89			'files': [90				'../base/',91				'../second/',92				'../link',93			],94		},95		'conditions': [96			['OS=="amiga"', {97				'variables': {98					'command': ['amiga', '<(EXTRA)'],99				},100			}],101			['OS=="win"', {102				'variables': {103					'command': ['win'],104				},105			}],106		],107	}`108		isolatePath := filepath.Join(fooDir, "baz.isolate")109		So(ioutil.WriteFile(isolatePath, []byte(isolate), 0600), ShouldBeNil)110		if !IsWindows() {111			So(os.Symlink(filepath.Join("base", "bar"), filepath.Join(tmpDir, "link")), ShouldBeNil)112		} else {113			So(ioutil.WriteFile(filepath.Join(tmpDir, "link"), []byte("no link on Windows"), 0600), ShouldBeNil)114		}115		opts := &ArchiveOptions{116			Isolate:         isolatePath,117			Isolated:        filepath.Join(tmpDir, "baz.isolated"),118			Blacklist:       stringlistflag.Flag{"ignored", "*.isolate"},119			PathVariables:   map[string]string{"VAR": "wonderful"},120			ExtraVariables:  map[string]string{"EXTRA": "really"},121			ConfigVariables: map[string]string{"OS": "amiga"},122		}123		item := Archive(a, opts)124		So(item.DisplayName, ShouldResemble, "baz.isolated")125		item.WaitForHashed()126		So(item.Error(), ShouldBeNil)127		So(a.Close(), ShouldBeNil)128		mode := 0600129		if IsWindows() {130			mode = 0666131		}132		//   /base/133		baseIsolatedData := isolated.Isolated{134			Algo: "sha-1",135			Files: map[string]isolated.File{136				filepath.Join("base", "bar"): isolated.BasicFile("0beec7b5ea3f0fdbc95d0dd47f3c5bc275da8a33", mode, 3),137			},138			Version: isolated.IsolatedFormatVersion,139		}140		encoded, err := json.Marshal(baseIsolatedData)141		So(err, ShouldBeNil)142		baseIsolatedEncoded := string(encoded) + "\n"143		baseIsolatedHash := isolated.HashBytes([]byte(baseIsolatedEncoded))144		//   /second/145		secondIsolatedData := isolated.Isolated{146			Algo: "sha-1",147			Files: map[string]isolated.File{148				filepath.Join("second", "boz"): isolated.BasicFile("aaadd94977b8fbf3f6fb09fc3bbbc9edbdfa8427", mode, 4),149			},150			Version: isolated.IsolatedFormatVersion,151		}152		encoded, err = json.Marshal(secondIsolatedData)153		So(err, ShouldBeNil)154		secondIsolatedEncoded := string(encoded) + "\n"155		secondIsolatedHash := isolated.HashBytes([]byte(secondIsolatedEncoded))156		isolatedData := isolated.Isolated{157			Algo:    "sha-1",158			Command: []string{"amiga", "really"},159			Files:   map[string]isolated.File{},160			// This list must be in deterministic order.161			Includes:    isolated.HexDigests{baseIsolatedHash, secondIsolatedHash},162			RelativeCwd: "foo",163			Version:     isolated.IsolatedFormatVersion,164		}165		if !IsWindows() {166			isolatedData.Files["link"] = isolated.SymLink(filepath.Join("base", "bar"))167		} else {168			isolatedData.Files["link"] = isolated.BasicFile("12339b9756c2994f85c310d560bc8c142a6b79a1", 0666, 18)169		}170		encoded, err = json.Marshal(isolatedData)171		So(err, ShouldBeNil)172		isolatedEncoded := string(encoded) + "\n"173		isolatedHash := isolated.HashBytes([]byte(isolatedEncoded))174		expected := map[string]string{175			"0beec7b5ea3f0fdbc95d0dd47f3c5bc275da8a33": "foo",176			"aaadd94977b8fbf3f6fb09fc3bbbc9edbdfa8427": "foo2",177			string(baseIsolatedHash):                   baseIsolatedEncoded,178			string(isolatedHash):                       isolatedEncoded,179			string(secondIsolatedHash):                 secondIsolatedEncoded,180		}181		if IsWindows() {182			expected["12339b9756c2994f85c310d560bc8c142a6b79a1"] = "no link on Windows"183		}184		actual := map[string]string{}185		for k, v := range server.Contents() {186			actual[string(k)] = string(v)187			So(actual[string(k)], ShouldResemble, expected[string(k)])188		}189		So(actual, ShouldResemble, expected)190		So(item.Digest(), ShouldResemble, isolatedHash)191		stats := a.Stats()192		So(stats.TotalHits(), ShouldBeZeroValue)193		So(stats.TotalBytesHits(), ShouldResemble, units.Size(0))194		size := 3 + 4 + len(baseIsolatedEncoded) + len(isolatedEncoded) + len(secondIsolatedEncoded)195		if !IsWindows() {196			So(stats.TotalMisses(), ShouldEqual, 5)197			So(stats.TotalBytesPushed(), ShouldResemble, units.Size(size))198		} else {199			So(stats.TotalMisses(), ShouldEqual, 6)200			// Includes the duplicate due to lack of symlink.201			So(stats.TotalBytesPushed(), ShouldResemble, units.Size(size+18))202		}203		So(server.Error(), ShouldBeNil)204		digest, err := isolated.HashFile(filepath.Join(tmpDir, "baz.isolated"))205		So(digest, ShouldResemble, isolateservice.HandlersEndpointsV1Digest{Digest: string(isolatedHash), IsIsolated: false, Size: int64(len(isolatedEncoded))})206		So(err, ShouldBeNil)207	})208}209// Test that if the isolate file is not found, the error is properly propagated.210func TestArchiveFileNotFoundReturnsError(t *testing.T) {211	t.Parallel()212	ctx := context.Background()213	Convey(`The client should handle missing isolate files.`, t, func() {214		a := archiver.New(ctx, isolatedclient.New(nil, nil, "http://unused", isolatedclient.DefaultNamespace, nil, nil), nil)215		opts := &ArchiveOptions{216			Isolate:  "/this-file-does-not-exist",217			Isolated: "/this-file-doesnt-either",218		}219		item := Archive(a, opts)220		item.WaitForHashed()221		err := item.Error()222		So(strings.HasPrefix(err.Error(), "open /this-file-does-not-exist: "), ShouldBeTrue)223		closeErr := a.Close()224		So(closeErr, ShouldNotBeNil)225		So(strings.HasPrefix(closeErr.Error(), "open /this-file-does-not-exist: "), ShouldBeTrue)226	})227}...

Using AI Code Generation

1import (2func main() {3	i := isolated.New(10)4	defer i.Close()5	fmt.Println(i)6}7import (8func main() {9	i := isolated.New(10)10	defer i.Close()11	fmt.Println(i)12}13import (14func main() {15	i := isolated.New(10)16	defer i.Close()17	fmt.Println(i)18}19import (20func main() {21	i := isolated.New(10)22	defer i.Close()23	fmt.Println(i)24}25import (26func main() {27	i := isolated.New(10)28	defer i.Close()29	fmt.Println(i)30}31import (32func main() {33	i := isolated.New(10)34	defer i.Close()35	fmt.Println(i)36}37import (38func main() {39	i := isolated.New(10)40	defer i.Close()41	fmt.Println(i)42}43import (44func main() {45	i := isolated.New(10)46	defer i.Close()47	fmt.Println(i)48}49import (50func main() {51	i := isolated.New(10)

Using AI Code Generation

1import "fmt"2import "math"3func main(){4    fmt.Println("Enter the values of a,b,c")5    fmt.Scanln(&a,&b,&c)6    if d > 0 {7        x1 = (-b + math.Sqrt(d))/(2*a)8        x2 = (-b - math.Sqrt(d))/(2*a)9        fmt.Println("The roots are",x1,x2)10    } else if d == 0 {11        x1 = -b/(2*a)12        fmt.Println("The root is",x1)13    } else {14        fmt.Println("No real root exists")15    }16}

Using AI Code Generation

1import (2func main() {3 i2 = p1.Isolated{Id: 2, Name: "Isolated 2"}4 fmt.Println(i2)5 i2.Close()6}

Using AI Code Generation

1import (2func main() {3	isolated.Close()4	fmt.Println("2.go: main() function")5}6import "fmt"7func Close() {8	fmt.Println("isolated.go: Close() function")9}10import (11func main() {12	isolated.Close()13	fmt.Println("3.go: main() function")14}15import "fmt"16func Close() {17	fmt.Println("isolated.go: Close() function")18}19isolated.go: Close() function201.go: main() function21isolated.go: Close() function222.go: main() function23isolated.go: Close() fun

Using AI Code Generation

1import (2func main() {3    fmt.Println("Hello, World!")4    fmt.Println("The value of Pi is ", math.Pi)5    fmt.Println("The value of Pi is ", math.Pi)6    fmt.Println("The value of Pi is ", math.Pi)7}8import (9func main() {10    fmt.Println("Hello, World!")11    fmt.Println("The sum of 5 and 6 is ", math.Add(5, 6))12    fmt.Println("The product of 5 and 6 is ", math.Multiply(5, 6))13}

Using AI Code Generation

1import (2func main() {3    fmt.Println("Hello World")4    var obj = new (isolated.Isolated)5    obj.Close()6}7import "fmt"8type Isolated struct {9}10func (isolated Isolated) Close() {11    fmt.Println("Close")12}13./2.go:8: cannot use obj (type *isolated.Isolated) as type isolated.Isolated in argument to isolated.Isolated.Close14import "fmt"15type Isolated struct {16}17func (isolated *Isolated) Close() {18    fmt.Println("Close")19}20import (21func main() {22    fmt.Println("Hello World")23    var obj = new (isolated.Isolated)24    obj.Close()25}26import "fmt"27type Isolated struct {28}29func (isolated *Isolated) Close() {30    fmt.Println("Close")31}

Automation Testing Tutorials

Learn to execute automation testing from scratch with LambdaTest Learning Hub. Right from setting up the prerequisites to run your first automation test, to following best practices and diving deeper into advanced test scenarios. LambdaTest Learning Hubs compile a list of step-by-step guides to help you be proficient with different test automation frameworks i.e. Selenium, Cypress, TestNG etc.