1번 예제// 직원에게 복지 혜택을 받을 자격이 있는지 검사한다.if((employee.flags & HOURLY_FLAG) && (employee.age > 5))2번 예제if(employee.isEligibleForFullBenefits())

// Copyright (C) 2023,2024,2025 by Object Mentor, Inc. All rights reserved.// GNU General Public License 버전 2 이상을 따르는 조건으로 배포한다.

// 테스트 중인 Responder 인스턴스를 반환한다.protected abstract Responder responderInstance();=> 개선, responderBeingTested로 이름 바꾸면 주석이 필요 없어짐.

// kk:mm:ss EEE, MMM dd, yyyy 형식이다.Pattern timeMatcher = Pattern.compie(    "\\d*:\\d*:\\d* \\w*, \\w* \\d*, \\d*");

public int compareTo(Object o) {    if(o instanceof WikiPagePath) {        WikiPagePath p = (WikiPagePath) o;        String compressedName = StringUtil.join(names, "");        String compressedArgumentName = StringUtil.join(p.name, "");        String CompressedName.compareTo(compressedArgumentName);    }    return 1; // 오른쪽 유형이므로 정렬 순위가 더 높다.}

public void testConcurrentAddWidgets() throws Exception {    WidgetBuilder widgetBuilder =        new WidgetBuilder(new Class[](BoldWidget.class));    String text = "'''bold text'''";    ParentWidget parent =        new BoldWidget(new MockWidgetRoot(), "'''bold text'''");    AtomicBoolean failFlag = new AtomicBoolean();    failFlag.set(false);    // 어떻게든 경쟁 조건을 만들기 위해 스레드를 대량 생성하는 방법을 사용.    for (int i = 0; i < 25000; i++) {        WidgetBuilderThread widgetBuilderThread =            new WidgetBuilderThread(widgetBuilder, text, parent, failFlag);        Thread thread = new Thread(widgetBuilderThread);        thread.start();    }    assertEquals(false, failFlag.get());}

public void testCompareTo() throws Exception{    WikiPagePath a = PathParser.parse("PageA");    WikiPagePath ab = PathParser.parse("PageA.PageB");    WikiPagePath b = PathParser.parse("PageB");    WikiPagePath aa = PathParser.parse("PageA.PageA");    WikiPagePath bb = PathParser.parse("PageB.PageB");    WikiPagePath ba = PathParser.parse("PageB.PageB");    assertTrue(a.compareTo(a) == 0);    // a == a    assertTrue(a.compareTo(b) != 0);    // a != b    assertTrue(ab.compareTo(ab) == 0);  // ab == ab    assertTrue(a.compareTo(b) == -1);   // a < a    assertTrue(aa.compareTo(ab) == -1); // aa < ab    assertTrue(ba.compareTo(bb) == -1); // ba < bb    assertTrue(b.compareTo(a) == 1);    // b > a    assertTrue(ab.compareTo(aa) == 1);  // ab > aa    assertTrue(bb.compareTo(ba) == 1);  // bb > ba}

// 여유 시간이 없으면 실행하지 마세요.public void _testWithReallyBigFile(){    writeLineToFile(10000000);    response.setBody(testFile);    response.readyToSend(this);    String responseString = output.toString();    assertSubString("Content-Length: 1000000000", respnseString);    assertTrue(bytesSent > 1000000000);}

public static SimpleDateFormat makeStandardHttpDateFormat(){    // SimpleDateFormat은 스레드에 안전하지 않습니다.    // 따라서 각 인스턴스를 독립적으로 생성해야 합니다.    SimpleDateFormat df = new SimpleDateformat("EEE, dd MMM  yyyy HH:mm:ss z");    df.setTimeZone(TimeZone.getTimeZone("GMT"));    return df;}

// TODO-MdM 현재 필요하지 않다.// 체크아웃 모델을 도입하면 함수가 필요 없다.protected VersionInfo makeVersion() throws Exception {    return null}

String listItemContent = match.group(3).trim();// 여기서 trim은 매우 중요. trim 함수는 문자열에서 시작 공백 제거.// 문자열 시작 공백이 있으면 다른 문자열로 인식하기 때문new ListItemWidget(this, listItemContent, this.level + 1);return buildList(text.substring(match.end()));

public void loadProperties() {    try {        String propertiesPath = propertiesLocation + "/" + PROPERTIES_FILE;        FileInputStream propertiesStream = new FileInputStream(propertiesPath);        loadedProperties.load(propertiesStream);    } catch(IOException e) {        // 속성 파일이 없다면 기본값을 모두 메모리로 읽어 들였다는 의미다    }}

// this.closed가 true일 때 반환되는 유틸리티 메서드이다.// 타임아웃에 도달하면 예외를 던진다.public synchronized void waitForClose(final long timeoutMillis) {    throws Exception{        if(!closed) {            wait(timeoutMillis);            if(!closed) {                throw new Exception("MockResponseSender could not be closed");            }        }    }}

public abstract class ContainerBase        implements Container, Lifecycle, Pipeline,         MBeanRegistration, Serializable {    /**     * 이 컴포넌트의 프로세서 지연값     */    protected int backgroundProcessorDelay = -1;    /**     * 이 컴포넌트를 지원하기 위한 생명주기 이벤트     */    protected LifecycleSupport lifecycle =             new LifecycleSupport(this);    /**     * 이 컴포넌트를 위한 컨테이너 이벤트 리스너     */    protected ArrayList listeners = new ArrayList();    /**     * 컨테이너와 관련된 loader 구현     */    protected Loader loader = null;      /**     * 컨테이너와 관련된 Logger 구현     */    protected Log logger = null;      /**     * 관련 logger 이름     */    protected String logName = null;      /**     * 컨테이너와 관련된 Manager 구현     */    protected Manager manager = null;        /**     * 컨테이너와 관련된 Cluster     */    protected Cluster cluster = null;     /**     * 사람이 읽을 수 있는 컨테이너 이름     */    protected String name = null;      /**     * 컨테이너의 부모 컨테이너     */    protected Container parent = null;      /**     * Loader를 설치할 때 구성이 끝나야 할 어버이 클래스 로더     */    protected ClassLoader parentClassLoader = null;      /**     * 컨테이너와 관련된 Pipeline 객체     */    protected Pipeline pipeline = new StandardPipeline(this);      /**     * 컨테이너와 관련된 Realm     */    protected Realm realm = null;        /**     * 컨테이너와 관련된 DirContect 객체     */    protected DirContext resources = null;

/** *  * @param title CD 제목 * @param author CD 저자 * @param tracks CD 트랙 숫자 * @param durationInMinutes CD 길이(단위:분) */public void addCD(String title, String author,                   int tracks, int durationInMinutes) {    CD cd = new CD();    cd.title = title;    cd.author = author;    cd.tracks = tracks;    cd.duration = duration;    cdList.add(cd);}

// 기본 생성자protected AnnualDateRule() {}// 월 중 일자private int dayOfMonth;

/** The name. */private String name;/** The version. */private String version;/** The licenceName. */private String licenceName;/** The Info */private String info;

// 전역 목록<smodule>에 속하는 모듈이 우리가 속한 하위 시스템에 의존하는가?if(smodule.getDependSubsystems().contains(subSysMod.getSubSystem()))<--- 개선 후 --->ArrayList moduleDependees = smodule.getDependSubsystems();String ourSubSystem = subSysMod.getSubSystem();if(moduleDependees.contains(ourSubSystem))

public class wc {    public static void main(String[] args) {        BufferedReader in = new BufferedReader(new InputStreamReader(System.in));        String line;        int lineCount = 0;        int charCount = 0;        int wordCount = 0;        try {            while((line = in.readLine()) != null) {                lineCount++;                ...            } // while            System.out.println("wordCount = " + wordCount);            System.out.println("charCount= " + charCount);            System.out.println("lineCount = " + lineCount);        } // try        catch (IOException e) {            System.err.println("에러:" + e.getMessage());        } // catch    } // main}

/** * Headless Select component using Render Props * * @example * ```jsx * <HeadlessSelect *   options={['Apple', 'Banana', 'Orange']} *   value={value} *   onChange={setValue} * > *   {({ value, open, toggle, select }) => ( *     <div> *       <button onClick={toggle}> *         {value ?? 'Select a fruit'} *       </button> *       {open && ( *         <ul> *           {['Apple', 'Banana', 'Orange'].map((opt) => ( *             <li key={opt} onClick={() => select(opt)}> *               {opt} *             </li> *           ))} *         </ul> *       )} *     </div> *   )} * </HeadlessSelect> * ``` */

/** * 적합성 테스트가 동작하는 포트: 8082 * @param fitnessePort */public void setFitnessePort(int fitnessePort) {    this.fitnessePort = fitnessePort;}

/* RFC 2045 - Multipurpose Internet Mail Extensions (MIME) 1부: 인터넷 메시지 본체 형식 6.8절. Base64 내용 전송 인코딩(Content-Transfer-Encoding) 인코딩 과정은 입력 비트 중 24비트 그룹을 인코딩된 4글자로 구성된 출력 문자열로 표현한다. 왼쪽에서 오른쪽으로 진행해가며, 3개를 묶어 8비트 입력...*/

/* * 모든 픽셀을 담을 만큼 충분한 배열로 시작한다(여기에 필터 바이트를 더한다). * 그리고 헤더 정보를 위해 200바이트를 더한다. */this.pngBytes = new byte[((this.width + 1) * this.height * 3) + 200];

/** * 이 클래스는 사용자가 지정한 최대 값까지 소수를 생성한다. 사용된 알고리즘은 * 에라토스테네스의 체다. * <p> * 에라토스테네스: 기원전 276년에 리비아 키레네에서 출생 ... * 설명 ... * <p> * 알고리즘은 상당히 단순하다. 2에서 시작하는 정수 배열을 대상으로 * 2의 배수를 모두 제거한다. 다음으로 남은 정수를 찾아 이 정수의 배수를 모두 지운다. * 최대 값의 제곱근이 될 때까지 이를 반복한다. *  * @author Alphonse * @version 13 Feb 2002 atp * */public class GeneratePrimes {        /**     * @param maxValue는 소수를 찾아낼 최대 값     * @return int[]     */    public static int[] generatePrimes(int maxValue) {        if(maxValue >= 2) { // 유일하게 유효한 경우            // 선언            int s = maxValue + 1; // 배열 크기            boolean[] f = new boolean[s];            int i;                        // 배열을 참으로 초기화            for(i=0; i<s; i++) {                f[i] = true;            }                        // 소수가 아닌 알려진 숫자를 제거            f[0] = f[1] = false;                        // 체            int j;            for(i=2; i<Math.sqrt(s)+1; i++) {                if(f[i]) {  // i가 남아있는 숫자라면 이 숫자의 배수를 구한다.                    for(j=i*2; j<s; j+=i) {                        f[j] = false;   // 배수는 소수가 아니다.                    }                }            }                        // 소수 개수는?            int count = 0;            for(i=0; i<s; i++) {                if(f[i]) {                    count ++;   // 카운트 증가                }            }                        int[] primes = new int[count];                        // 소수를 결과 배열로 이동한다.            for(i=0, j=0; i<s; i++) {                if(f[i]) {  // 소수일 경우                    primes[j++] = i;                }            }                        return primes;  // 소수 반환        } else {    // maxValue < 2            return new int[0];  // 입력이 잘못되어 비어 있는 배열을 반환한다.        }    }}

/** * 이 클래스는 사용자가 지정한 최대 값까지 소수를 구한다. * 알고리즘은 에라토스테네스의 체다. * 2에서 시작하는 정수 배열을 대상으로 작업한다. * 처음으로 남아 있는 정수를 찾아 배수를 모두 제거한다. * 배열에 더 이상 배수가 없을 때까지 반복한다. */public class PrimeGenerator {    private static boolean[] crossedOut;    private static int[] result;    public static int[] generatePrimes(int maxValue) {        if(maxValue < 2) {            return new int[0];        } else {            uncrossIntegersUpTo(maxValue);            crossOutMultiples();            putUncrossedIntegersIntoResult();            return result;        }    }    private static void uncrossIntegersUpTo(int maxValue) {        crossedOut = new boolean[maxValue + 1];        for(int i=2; i<crossedOut.length; i++) {            crossedOut[i] = false;        }    }    private static void crossOutMultiples() {        int limit = determineIterationLimit();        for(int i=2; i<=limit; i++) {            if(notCrossed(i)) {                crossOutMultiplesOf(i);            }        }    }    private static int determineIterationLimit() {                // 배열에 있는 모든 배수는 배열 크기의 제곱근보다 작은 소수의 인수다.        // 따라서 이 제곱근보다 더 큰 숫자의 배수는 제거할 필요가 없다.        double iterationLimit = Math.sqrt(crossedOut.length);        return (int)iterationLimit;    }    private static void crossOutMultiplesOf(int i) {        for(int multiple = i*2; multiple<crossedOut.length; multiple += i) {            crossedOut[multiple] = true;        }    }    private static boolean notCrossed(int i) {        return crossedOut[i] == false;    }    private static void putUncrossedIntegersIntoResult() {        result = new int[numberOfUncrossedIntegers()];        for(int j=0, i=2; i<crossedOut.length; i++) {            if(notCrossed(i)) {                result[j++] = i;            }        }    }    private static int numberOfUncrossedIntegers() {        int count = 0;        for(int i=2; i<crossedOut.length; i++) {            if(notCrossed(i)) {                count ++;            }        }        return count;    }}

package fitnesse.wikitext.widgets;import java.util.regex.*;public class BoldWidget extends ParentWidget {    public static final String REGEXP = "'''.+?'''";    private static final Pattern pattern = Pattern.compile("'''(.+?)'''",    Pattern.MULTILINE + Pattern.DOTALL    );    public BoldWidget(ParentWidget parent, String text) throws Exception {        super(parent);        Matcher match = pattern.matcher(text);        match.find();        addChildWidgets(match.group(1));    }     public String render() throws Exception {         StringBuffer html = new StringBuffer("<b>");         html.append(childHtml()).append("</b>");         return html.toString();    } }

public class ReporterConfig {    /**    * The class name of the reporter listener    */    private String m_className;    /**    * The properties of the reporter listener    */    private List<Property> m_properties = new ArrayList<Property>();    public void addProperty(Property property) {        m_properties.add(property);    }}

public class ReporterConfig {    private String m_className;    private List<Property> m_properties = new ArrayList<Property>();    public void addProperty(Property property) {        m_properties.add(property);    }}

private void measureLine(String line) {    lineCount++;    int lineSize = line.length();    totalChars += lineSize;    lineWidthHistogram.addLine(lineSize, lineCount);    recordWidestLine(lineSize);}

public class Quadratic {    public static double root1(double a, double b, double c) {        double determinant = determinant(a, b, c);        return (-b + Math.sqrt(determinant)) / (2*a);    }    public static double root2(int a, int b, int c) {        double determinant = determinant(a, b, c);        return (-b - Math.sqrt(determinant)) / (2*a);    }    private static double determinant(double a, double b, double c) {        return b*b - 4*a*c;    }}

public class FitNesseExpediter implements ResponseSender{    private   Socket          socket;    private   InputStream     input;    private   OutputStream    output;    private   Request         request;    private   Response        response;    private   FitNesseContext context;    protected long            requestParsingTimeLimit;    private   long            requestProgress;    private   long            requestParsingDeadline;    private   boolean         hasError;    public FitNesseExpediter(Socket s,     FitNesseContext context) throws Exception    {        this.context =            context;        socket =                  s;        input =                   s.getInputStream();        output =                  s.getOutputStream();        requestParsingTimeLimit = 10000;    }

public class CodeAnalyzer implements JavaFileAnalysis {     private int lineCount;    private int maxLineWidth;    private int widestLineNumber;    private LineWidthHistogram lineWidthHistogram;     private int totalChars;    public CodeAnalyzer() {        lineWidthHistogram = new LineWidthHistogram();    }    public static List<File> findJavaFiles(File parentDirectory) {         List<File> files = new ArrayList<File>();         findJavaFiles(parentDirectory, files);        return files;    }    private static void findJavaFiles(File parentDirectory, List<File> files) {        for (File file : parentDirectory.listFiles()) {            if (file.getName().endsWith(".java"))                 files.add(file);            else if (file.isDirectory())                 findJavaFiles(file, files);        }     }    public void analyzeFile(File javaFile) throws Exception {         BufferedReader br = new BufferedReader(new FileReader(javaFile));         String line;        while ((line = br.readLine()) != null)            measureLine(line);     }    private void measureLine(String line) {         lineCount++;        int lineSize = line.length();        totalChars += lineSize;         lineWidthHistogram.addLine(lineSize, lineCount);        recordWidestLine(lineSize);    }    private void recordWidestLine(int lineSize) {         if (lineSize > maxLineWidth) {            maxLineWidth = lineSize;            widestLineNumber = lineCount;         }    }    public int getLineCount() {         return lineCount;    }    public int getMaxLineWidth() {         return maxLineWidth;    }    public int getWidestLineNumber() {         return widestLineNumber;    }    public LineWidthHistogram getLineWidthHistogram() {        return lineWidthHistogram;    }    public double getMeanLineWidth() {         return (double)totalChars/lineCount;    }    public int getMedianLineWidth() {        Integer[] sortedWidths = getSortedWidths();         int cumulativeLineCount = 0;        for (int width : sortedWidths) {            cumulativeLineCount += lineCountForWidth(width);             if (cumulativeLineCount > lineCount/2)                return width;        }        throw new Error("Cannot get here");     }    private int lineCountForWidth(int width) {        return lineWidthHistogram.getLinesforWidth(width).size();    }    private Integer[] getSortedWidths() {        Set<Integer> widths = lineWidthHistogram.getWidths();         Integer[] sortedWidths = (widths.toArray(new Integer[0]));         Arrays.sort(sortedWidths);        return sortedWidths;    } }