}
func (m *ExampleResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_ExampleResponse.DiscardUnknown(m)
}

var xxx_messageInfo_ExampleResponse proto.InternalMessageInfo

func (m *ExampleResponse) GetError() string {
	if m != nil {
		return m.Error
	}
	return ""
}

func init() {
	proto.RegisterType((*ExampleRequest)(nil), "v1beta2.ExampleRequest")

                artifact.setResolved(true);
            } else if (!artifact.getFile().exists()) {
                String error = updateCheckManager.getError(artifact, repository);
                if (error != null) {
                    throw new TransferFailedException("Failure to resolve " + remotePath + " from "
                            + repository.getUrl()

}
func (m *ExampleResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_ExampleResponse.DiscardUnknown(m)
}

var xxx_messageInfo_ExampleResponse proto.InternalMessageInfo

func (m *ExampleResponse) GetError() string {
	if m != nil {
		return m.Error
	}
	return ""
}

func init() {
	proto.RegisterType((*ExampleRequest)(nil), "v1beta1.ExampleRequest")

	}
	return mi.MessageOf(x)
}

// Deprecated: Use Ack.ProtoReflect.Descriptor instead.
func (*Ack) Descriptor() ([]byte, []int) {
	return file_zdsapi_zds_proto_rawDescGZIP(), []int{6}
}

func (x *Ack) GetError() string {
	if x != nil {
		return x.Error
	}
	return ""
}

// Sent from CNI to ztunnel
type WorkloadRequest struct {
	state         protoimpl.MessageState
	sizeCache     protoimpl.SizeCache

		}

		return node
	}

	cases := []struct {
		name            string
		newNode         *v1.Node
		existingNode    *v1.Node
		createError     error
		getError        error
		patchError      error
		deleteError     error
		expectedResult  bool
		expectedActions int
		testSavedNode   bool
		savedNodeIndex  int
		savedNodeCMAD   bool
	}{
		{

            reportBuilder.append("----------------------------------------------------------------------------------------------------\n")
            reportBuilder.append("${it.name}\n")
            reportBuilder.append(result.getError())
            reportBuilder.append("\n")
        }

        reportFile.text = reportBuilder.toString()
    }

    private void assertAllExceptionsInShowcase(TestFile reportFile) {

	if !actual.Equal(expected) {
		t.Errorf("unexpected deletes\nexpected: %v\n  actual: %v", expected.List(), actual.List())
	}
}

func TestStoreDaemonSetStatus(t *testing.T) {
	getError := fmt.Errorf("fake get error")
	updateError := fmt.Errorf("fake update error")
	tests := []struct {
		name                 string
		updateErrorNum       int
		getErrorNum          int

	v = ValueOf(a)
	if v.Cap() != cap(a) {
		t.Errorf("Cap = %d want %d", v.Cap(), cap(a))
	}

	getError := func(f func()) (errorStr string) {
		defer func() {
			e := recover()
			if str, ok := e.(string); ok {
				errorStr = str
			}
		}()
		f()
		return
	}
	e := getError(func() {
		var ptr *int
		ValueOf(ptr).Cap()
	})

        assertViolations(result, 0, 4, 0);

        assertContains(result.getErrors().get(0), "duplicate execution with id a");
        assertContains(result.getErrors().get(1), "duplicate execution with id default");
        assertContains(result.getErrors().get(2), "duplicate execution with id c");
        assertContains(result.getErrors().get(3), "duplicate execution with id b");
    }

    @Test

			t.Fatalf("Events() failed: got %v want %v", gotEvent, wantEvent)
		}

		wantError := fmt.Errorf("error=%v", file)
		fakeWatcher.InjectError(file, wantError)
		gotError := <-watcher.Errors(file)
		if gotError != wantError {
			t.Fatalf("Errors() failed: got %v want %v", gotError, wantError)
		}

		if err := watcher.Remove(file); err != nil {
			t.Fatalf("Remove() returned error: %v", err)
		}
		gotRemove := <-removedChan