How to retrieve all the values from an array which doesn't contain the input list in JMeter

Problem Statement : I have an input array (i.e.excludeStudyName) and I have a response array, I am trying to fetch the elements which doesn't contain the string given in the input array.

Input Array Value : ["Inflammation","Perf","Test_Study"]

Code for fetching all the value in the response contain the input array,

import groovy.json.JsonSlurper;

def fetchedStudyName = [] 
1.upto(vars.get('studyNameFetched_matchNr') as int, { index ->
    fetchedStudyName.add(vars.get('studyNameFetched_' + index))
});


String tempExcludeStudyName = vars.get('excludeStudyName'); 
def excludeStudyName = new JsonSlurper().parseText(tempExcludeStudyName);

def valid = fetchedStudyName.findAll  { a -> 
	excludeStudyName.any {a.contains(it)}
}

This is working fine,I am getting 48 values which contain. But I want which doesn't contain this value.

I tried with excludeStudyName.any {!a.contains(it)} and excludeStudyName.any {!(a.contains(it))} it is printing all the values from response array.

But not working. how to fix it ?

If you want to remove from fetchedStudyName all elements which are present in the excludeStudyName you could do something like:

def toRemove = excludeStudyName.intersect(fetchedStudyName)
fetchedStudyName.removeAll(toRemove)

More information:

• DefaultGroovyMethods.intersect()
• Groovy Goodness: Intersect Collections
• Apache Groovy: What Is Groovy Used For?

You were pretty close:

def valid = fetchedStudyName.findAll  { a -> 
    !excludeStudyName.contains(a)
}

should work.

If excludeStudyName is a large list you should think about changing it to a set to speed up contains(a):

Set excludeStudyName = new JsonSlurper().parseText(tempExcludeStudyName)

def valid = fetchedStudyName.findAll  { a -> 
    !excludeStudyName.contains(a)
}

Your current code grabs all of the values that match the excludeStudyName and returns them in valid. If you're goal is grab the values that do not match excludeStudyName, than here are some options.

def included = ["this", "is", "not", "here"]

def excluded = ["is"]

def valid = included.findAll  { a -> 
    excluded.any {a.contains(it)}
}

def valid1 = included.findAll  { a -> 
    excluded.every { val ->
        !a.contains(val)
    }
}

def valid2 = included.findAll  { a -> 
    !excluded.contains(a)
}

println("valid " + valid)
println("valid1 " + valid1)
println("valid2 " + valid2)

Output:
valid [this, is]
valid1 [not, here]
valid2 [this, not, here]

How about this approach,

a minor change to your code,

def valid = fetchedStudyName.findAll  { a -> 
    excludeStudyName.every { val ->
        !a.contains(val)
    }
}