Model source = Model.newBuilder().artifactId("SOURCE").build();

        Model merged = mavenMerger.merge(target, source, true, null);
        assertEquals(
                "SOURCE",
                merged.getArtifactId(),
                "Expected merged artifactId to be SOURCE but was " + merged.getArtifactId());

        merged = mavenMerger.merge(target, source, false, null);
        assertEquals(
                "TARGET",

    offset: int = 0,
    limit: int = Query(default=100, le=100),
):
    heroes = session.exec(select(Hero).offset(offset).limit(limit)).all()
    return heroes


@app.get("/heroes/{hero_id}", response_model=HeroPublic)
def read_hero(hero_id: int, session: Session = Depends(get_session)):
    hero = session.get(Hero, hero_id)
    if not hero:
        raise HTTPException(status_code=404, detail="Hero not found")
    return hero

    create_db_and_tables()


@app.post("/heroes/")
def create_hero(hero: Hero, session: SessionDep) -> Hero:
    session.add(hero)
    session.commit()
    session.refresh(hero)
    return hero


@app.get("/heroes/")
def read_heroes(
    session: SessionDep,
    offset: int = 0,
    limit: Annotated[int, Query(le=100)] = 100,
) -> list[Hero]:
    heroes = session.exec(select(Hero).offset(offset).limit(limit)).all()

func (l lastDayTierStats) merge(m lastDayTierStats) (merged lastDayTierStats) {
	cl := l.clone()
	cm := m.clone()

	if cl.UpdatedAt.After(cm.UpdatedAt) {
		cm.forwardTo(cl.UpdatedAt)
		merged.UpdatedAt = cl.UpdatedAt
	} else {
		cl.forwardTo(cm.UpdatedAt)
		merged.UpdatedAt = cm.UpdatedAt
	}

	for i := range cl.Bins {
		merged.Bins[i] = cl.Bins[i].add(cm.Bins[i])
	}

	return merged
}

                merged.put(key, element);
            }

            for (Repository element : recessive) {
                Object key = getRepositoryKey(element);
                if (!merged.containsKey(key)) {
                    merged.put(key, element);
                }
            }

            target.setRepositories(new ArrayList<>(merged.values()));
        }
    }

            Properties merged = new Properties();
            if (sourceDominant) {
                merged.putAll(target.getProperties());
                putAll(merged, source.getProperties(), CHILD_DIRECTORY_PROPERTY);
            } else {
                putAll(merged, source.getProperties(), CHILD_DIRECTORY_PROPERTY);
                merged.putAll(target.getProperties());
            }

   * @return the count of the element before the operation; possibly zero
   * @throws IllegalArgumentException if {@code count} is negative
   * @throws NullPointerException if {@code element} is null and this implementation does not permit
   *     null elements. Note that if {@code count} is zero, the implementor may optionally return
   *     zero instead.
   */
  @CanIgnoreReturnValue

        }

        @Test
        @DisplayName("toString uses hex authority when high bytes are non-zero")
        void testToStringHexAuthority() {
            byte[] ident = new byte[] { 1, 2, 3, 4, 5, 6 }; // high bytes non-zero -> hex representation
            SID sid = new SID(buildSidT((byte) 1, ident, 7, 8), jcifs.SID.SID_TYPE_USE_NONE, null, null, false);

		if _, err := io.ReadFull(tr.r, tr.blk[:]); err != nil {
			return nil, nil, err // EOF is okay here; exactly 1 block of zeros read
		}
		if bytes.Equal(tr.blk[:], zeroBlock[:]) {
			return nil, nil, io.EOF // normal EOF; exactly 2 block of zeros read
		}
		return nil, nil, ErrHeader // Zero block and then non-zero block
	}

	// Verify the header matches a known format.
	format := tr.blk.getFormat()

	}
	return int64(x)
}

func (f *formatter) formatOctal(b []byte, x int64) {
	if !fitsInOctal(len(b), x) {
		x = 0 // Last resort, just write zero
		f.err = ErrFieldTooLong
	}

	s := strconv.FormatInt(x, 8)
	// Add leading zeros, but leave room for a NUL.
	if n := len(b) - len(s) - 1; n > 0 {
		s = strings.Repeat("0", n) + s
	}
	f.formatString(b, s)
}