// Since we've encountered an unknown field, fallback to unstructured equality checking.
			ouMap, ok := other.(*unstructuredMap)
			if !ok {
				// The compiler ensures equality is against the same type of object, so this should be unreachable
				return types.MaybeNoSuchOverloadErr(other)
			}
			if oValue, ok := ouMap.value[key]; ok {
				if !equality.Semantic.DeepEqual(value, oValue) {
					return types.False
				}
			}

 * limitations under the License.
 */
package org.gradle.plugins.ide.idea.model

import spock.lang.Specification

class ModuleDependencyTest extends Specification {
    def equality() {
        expect:
        new ModuleDependency("a", null).equals(new ModuleDependency("a", "COMPILE"))
        new ModuleDependency("a", "").equals(new ModuleDependency("a", "COMPILE"))

 *
 * @since 4.0.0
 */
@Experimental
public interface ExtensibleEnum {

    /**
     * The {@code id} uniquely represents a value for this extensible enum.
     * This id should be used to compute the equality and hash code for the instance.
     *
     * @return the id
     */
    @Nonnull
    String id();

// For instance, I can make a transformation from `object => object.name` to only trigger events for changes to the name;
// the output will be compared (using standard equality checking), and only changes will trigger the handler.
// Note this is in addition to the normal event mechanics, so this can only filter things further.

class DefaultModuleVersionSelectorTest extends Specification {

    private final static ModuleIdentifier UTIL = DefaultModuleIdentifier.newId("org", "util")


    def "equality"() {
        def selector = newSelector(UTIL, "1.0")

        def same = newSelector(UTIL, "1.0")
        def diffGroup = newSelector(DefaultModuleIdentifier.newId("foo", "util"), "1.0")

 *
 * Keys are stored wrapped in {@code WeakIdentityHashMap.WeakKey} weak reference implementation, that uses {@code System.identityHashCode}
 * for generating hash code and considers referent equality for {@code equals} method.
 */
class WeakIdentityHashMap<K, V> {
    private final HashMap<WeakKey<K>, V> map = new HashMap<>();

    void put(K key, V value) {
        map.put(new WeakKey<>(key), value);
    }

   *   <li>If there is no visible constructor or visible static factory method declared by {@code
   *       C}, {@code C} is skipped for equality test.
   *   <li>Equality test is not performed on method return values unless the method is a visible
   *       static factory method whose return type is {@code C} or {@code C}'s subtype.
   * </ul>
   *

		{"!nil =? nil", &t1, nil, false},
	}

	for _, c := range cases {
		t.Run(c.name, func(t *testing.T) {
			result := c.x.Equal(c.y)
			if result != c.result {
				t.Errorf("Failed equality test for '%v', '%v': expected %+v, got %+v", c.x, c.y, c.result, result)
			}
		})
	}
}

func TestTimeBefore(t *testing.T) {
	t1 := NewTime(time.Now())
	cases := []struct {
		name string

			op.checkSuspect(pass, exprs)
		}
	})
	return nil, nil
}

type boolOp struct {
	name  string
	tok   token.Token // token corresponding to this operator
	badEq token.Token // token corresponding to the equality test that should not be used with this operator
}

var (
	or  = boolOp{"or", token.LOR, token.NEQ}
	and = boolOp{"and", token.LAND, token.EQL}
)

// commutativeSets returns all side effect free sets of

limitations under the License.
*/

package internalbootstrap

import (
	"fmt"
	"testing"

	"github.com/google/go-cmp/cmp"

	flowcontrol "k8s.io/api/flowcontrol/v1"
	apiequality "k8s.io/apimachinery/pkg/api/equality"
	"k8s.io/apiserver/pkg/apis/flowcontrol/bootstrap"
)

func TestBootstrapConfigurationWithDefaulted(t *testing.T) {
	scheme := NewAPFScheme()

	bootstrapFlowSchemas := make([]*flowcontrol.FlowSchema, 0)