### What is a Process

The word **process** is normally used in a more specific way, only referring to the thing that is running in the operating system (like in the last point above):

* A particular program while it is **running** on the operating system.
    * This doesn't refer to the file, nor to the code, it refers **specifically** to the thing that is being **executed** and managed by the operating system.

		t.Skip()
	}

	type Thing struct {
		gorm.Model
		SomeID  string
		OtherID string
		Data    string
	}

	DB.Migrator().DropTable(&Thing{})
	DB.Migrator().CreateTable(&Thing{})
	if err := DB.Exec("ALTER TABLE things ADD CONSTRAINT some_id_other_id_unique UNIQUE (some_id, other_id)").Error; err != nil {
		t.Error(err)
	}

	thing := Thing{
		SomeID:  "1234",
		OtherID: "1234",

  default <T> T newProxy(T target, Class<T> interfaceType, Duration timeout) {
    return newProxy(target, interfaceType, toNanosSaturated(timeout), TimeUnit.NANOSECONDS);
  }

  /**
   * Invokes a specified Callable, timing out after the specified time limit. If the target method
   * call finishes before the limit is reached, the return value or a wrapped exception is

   * - median with compute taking a double-collection and with computeInPlace;
   * - quartiles with index and with indexes taking int-varargs, and with compute taking a
   *   double-collection and with computeInPlace;
   * - scale with index and with indexes taking int-varargs, and with all overloads of compute
   *   taking a double-collection and with computeInPlace;

        }
        msg += ")";
        logger.debug(msg);
    }

    public void manageArtifactVersion(Artifact artifact, Artifact replacement) {
        // only show msg if a change is actually taking place
        if (!replacement.getVersion().equals(artifact.getVersion())) {
            String msg = indent + artifact + " (applying version: " + replacement.getVersion() + ")";
            logger.debug(msg);
        }

        } else if (artifact.isSnapshot() || !artifact.getFile().exists()) {
            if (force || updateCheckManager.isUpdateRequired(artifact, repository)) {
                logger.debug("Trying repository " + repository.getId() + " for resolution of " + artifact.getId()
                        + " from " + remotePath);

                try {
                    getRemoteFile(

        assertFalse(new Dependency().equals(null));

        new Dependency().equals(new Dependency());
    }

    @Test
    void testEqualsIdentity() {
        Dependency thing = new Dependency();
        assertTrue(thing.equals(thing));
    }

    @Test
    void testToStringNullSafe() {
        assertNotNull(new Dependency().toString());
    }

        new DistributionManagement().equals(new DistributionManagement());
    }

    @Test
    void testEqualsIdentity() {
        DistributionManagement thing = new DistributionManagement();
        assertTrue(thing.equals(thing));
    }

    @Test
    void testToStringNullSafe() {
        assertNotNull(new DistributionManagement().toString());
    }

        assertFalse(new Exclusion().equals(null));

        new Exclusion().equals(new Exclusion());
    }

    @Test
    void testEqualsIdentity() {
        Exclusion thing = new Exclusion();
        assertTrue(thing.equals(thing));
    }

    @Test
    void testToStringNullSafe() {
        assertNotNull(new Exclusion().toString());
    }

        assertFalse(new Plugin().equals(null));

        new Plugin().equals(new Plugin());
    }

    @Test
    void testEqualsIdentity() {
        Plugin thing = new Plugin();
        assertTrue(thing.equals(thing));
    }

    @Test
    void testToStringNullSafe() {
        assertNotNull(new Plugin().toString());
    }