hunk.code_window: 	})
   	t.Run("ping feature flag test", func(t *testing.T) {
   		resp, appErr := th.Client.DoApiGet(th.Client.GetSystemRoute()+"/ping", "")
   		require.Nil(t, appErr)
   		require.Equal(t, http.StatusOK, resp.StatusCode)
   		respBytes, err := ioutil.ReadAll(resp.Body)
   		require.Nil(t, err)
  
hunk.labels: keep replace replace replace replace keep keep keep keep
hunk.after_edit: 	th.TestForAllClients(t, func(t *testing.T, client *model.Client4) {
   		resp, appErr := client.DoApiGet(client.GetSystemRoute()+"/ping", "")
  
hunk.file_path: api4/system_test.go
hunk.type: replace
file: package jmespath
  
  import "strconv"
  
  // JMESPath is the representation of a compiled JMES path query. A JMESPath is
  // safe for concurrent use by multiple goroutines.
  type JMESPath struct {
  	ast  ASTNode
  	intr *treeInterpreter
  }
  
  // Compile parses a JMESPath expression and returns, if successful, a JMESPath
  // object that can be used to match against data.
  func Compile(expression string) (*JMESPath, error) {
  	parser := NewParser()
  	ast, err := parser.Parse(expression)
  	if err != nil {
  		return nil, err
  	}
  	jmespath := &JMESPath{ast: ast, intr: newInterpreter()}
  	return jmespath, nil
  }
  
  // MustCompile is like Compile but panics if the expression cannot be parsed.
  // It simplifies safe initialization of global variables holding compiled
  // JMESPaths.
  func MustCompile(expression string) *JMESPath {
  	jmespath, err := Compile(expression)
  	if err != nil {
  		panic(`jmespath: Compile(` + strconv.Quote(expression) + `): ` + err.Error())
  	}
  	return jmespath
  }
  
  // Search evaluates a JMESPath expression against input data and returns the result.
  func (jp *JMESPath) Search(data interface{}) (interface{}, error) {
  	return jp.intr.Execute(jp.ast, data)
  }
  
  // Search evaluates a JMESPath expression against input data and returns the result.
  func Search(expression string, data interface{}) (interface{}, error) {
  	intr := newInterpreter()
  	parser := NewParser()
  	ast, err := parser.Parse(expression)
  	if err != nil {
  		return nil, err
  	}
  	return intr.Execute(ast, data)
  }
  