সমতুল্য পদ্ধতি ব্যতীত আমি দুটি শ্রেণিতে কীভাবে সমতা জোর করব?

111

বলুন আমার সমান () পদ্ধতি ছাড়াই একটি শ্রেণি রয়েছে, যার উত্স নেই। আমি এই শ্রেণীর দুটি দৃষ্টিতে সমতা জোর করতে চাই।

আমি একাধিক সংস্থান করতে পারি:

assertEquals(obj1.getFieldA(), obj2.getFieldA());
assertEquals(obj1.getFieldB(), obj2.getFieldB());
assertEquals(obj1.getFieldC(), obj2.getFieldC());
...

আমি এই সমাধানটি পছন্দ করি না কারণ প্রথম দিকের প্রতিবেদন ব্যর্থ হলে আমি সম্পূর্ণ সমতা চিত্র পাই না don't

আমি নিজে নিজেই তুলনা করতে পারি এবং ফলাফলটি ট্র্যাক করতে পারি:

String errorStr = "";
if(!obj1.getFieldA().equals(obj2.getFieldA())) {
    errorStr += "expected: " + obj1.getFieldA() + ", actual: " + obj2.getFieldA() + "\n";
}
if(!obj1.getFieldB().equals(obj2.getFieldB())) {
    errorStr += "expected: " + obj1.getFieldB() + ", actual: " + obj2.getFieldB() + "\n";
}
...
assertEquals("", errorStr);

এটি আমার সম্পূর্ণ সাম্যতার চিত্র দেয়, তবে আড়ম্বরপূর্ণ (এবং আমি সম্ভাব্য নাল সমস্যার জন্যও দায়বদ্ধ হইনি)। তৃতীয় বিকল্পটি তুলনামূলক ব্যবহার করা হয়, তবে তুলনা করুন () আমাকে কোন ক্ষেত্রের সমতা ব্যর্থ করে তা বলবে না।

সাবক্ল্যাসিং এবং ওভাররাইডিং ইকুয়াল (উঘ) ছাড়াই অবজেক্ট থেকে আমি যা চাই তা পাওয়ার কি আরও ভাল অনুশীলন আছে?

java  unit-testing  junit 
— রায়ান নেলসন
সূত্র
আপনি কি এমন একটি গ্রন্থাগার সন্ধান করছেন যা আপনার জন্য গভীর তুলনা করে? ডিপ- ইকুয়ালগুলির মতো স্ট্যাকওভারফ্লো . com/ জিজ্ঞাসা / 1449001/… এ পরামর্শ দেওয়া হয়েছে ?
— ভিকডোর
3
কেন দু'টি দৃষ্টান্ত সমান ছিল না তা আপনার জানতে হবে। সাধারণত, equalপদ্ধতির একটি প্রয়োগ কেবলমাত্র দুটি দৃষ্টান্ত সমান কিনা তা জানায় এবং কেন ইন্টান্সগুলি সমান নয় সে বিষয়ে আমাদের যত্ন নেই।
— ভেশে গুরুং
3
আমি কী বৈশিষ্ট্যগুলি অসম তা জানতে চাই যাতে আমি সেগুলি ঠিক করতে পারি। :)
— রায়ান নেলসন
সকলের Objectএকটি equalsপদ্ধতি রয়েছে, আপনি সম্ভবত বোঝাতে চেয়েছিলেন যে কোনও ওভাররাইড সমান পদ্ধতি নেই।
— স্টিভ কুও
আমি সবচেয়ে ভাল
— উপায়টি

উত্তর:

66

মকিতো একটি প্রতিবিম্ব-ম্যাচারের প্রস্তাব দেয়:

মকিতো ব্যবহারের সর্বশেষতম সংস্করণের জন্য:

Assert.assertTrue(new ReflectionEquals(expected, excludeFields).matches(actual));

পুরানো সংস্করণগুলির জন্য ব্যবহার করুন:

Assert.assertThat(actual, new ReflectionEquals(expected, excludeFields));
— felvhage
সূত্র
17
এই ক্লাসটি প্যাকেজে রয়েছে org.mockito.internal.matchers.apachecommons। মকিতো ডক্সে বলা হয়েছে: org.mockito.internal-> "অভ্যন্তরীণ ক্লাসগুলি, ক্লায়েন্টদের দ্বারা ব্যবহৃত হবে না। আপনি এটি ব্যবহার করে আপনার প্রকল্পটিকে ঝুঁকির মধ্যে ফেলবেন। এটি যে কোনও মকিতো সংস্করণে পরিবর্তন করতে পারে। এখানে পড়ুন: সাইট. mockito.org/mockito/docs/current/overview-summary.html
— luboskrnac
6
Mockito.refEq()পরিবর্তে ব্যবহার করুন।
— জেরেমি কাও
1
Mockito.refEq()বস্তুগুলির আইডি সেট না থাকলে ব্যর্থ হয় = (
— কেভপলো
1
@ পাইওটরএলিক্সান্ডার চামিয়ালোভস্কি, দুঃখিত, স্প্রিং + জেপিএ + সত্তার সাথে কাজ করার সময়, সত্তা অবজেক্টের একটি আইডি থাকতে পারে (ডাটাবেস টেবিলের আইডি ক্ষেত্রের প্রতিনিধিত্ব করে), তাই যখন এটি খালি হয় (একটি নতুন অবজেক্ট এখনও ডিবিতে সঞ্চিত নেই), refEqব্যর্থ হয় হ্যাশকোড পদ্ধতি হিসাবে বস্তুগুলির তুলনা করতে অক্ষম হিসাবে তুলনা করতে।
— কেভপলো
3
এটি সূক্ষ্মভাবে কাজ করে তবে প্রত্যাশিত এবং আসলটি ভুল ক্রমে থাকে। এটা কাছাকাছি অন্য কোন উপায়ে হওয়া উচিত।
— pkawiak
48

এখানে অনেক সঠিক উত্তর রয়েছে তবে আমি আমার সংস্করণটিও যুক্ত করতে চাই। এটি Assertj ভিত্তিক।

import static org.assertj.core.api.Assertions.assertThat;

public class TestClass {

    public void test() {
        // do the actual test
        assertThat(actualObject)
            .isEqualToComparingFieldByFieldRecursively(expectedObject);
    }
}

আপডেট: assertj v3.13.2 এ পদ্ধতিতে উডজ মন্তব্যে নির্দেশিত হিসাবে অবহিত করা হয়েছে। বর্তমানের সুপারিশটি হ'ল

public class TestClass {

    public void test() {
        // do the actual test
        assertThat(actualObject)
            .usingRecursiveComparison()
            .isEqualTo(expectedObject);
    }

}
— টমাস
সূত্র
3
Assertj v3.13.2 এ এই পদ্ধতিটি অবমূল্যায়ন করা হয়েছে এবং এখনই প্রস্তাবটিটি ব্যবহার usingRecursiveComparison()করা উচিত isEqualTo(), যেমন লাইনটিassertThat(actualObject).usingRecursiveComparison().isEqualTo(expectedObject);
— উডজ
45

আমি সাধারণত org.apache.commons.lang3.builder.EqualsBuilder ব্যবহার করে এই ইউসকেস বাস্তবায়ন করি

Assert.assertTrue(EqualsBuilder.reflectionEquals(expected,actual));
— অভিজিৎ কুশে
সূত্র
1
গ্রেডল: androidTestCompile 'org.apache.commons: Commons-lang3: 3.5'
— রোল
1
আপনি যখন "org.apache.commons.lang3.builder.EqualsBuilder" ব্যবহার করতে চান তখন আপনাকে "নির্ভরতা" এর অধীনে আপনার গ্রেড ফাইলটিতে এটি যুক্ত করতে হবে
— রোল
3
প্রকৃত ক্ষেত্রগুলি আসলে কী মিলছে না তাতে এটি কোনও ইঙ্গিত দেয় না।
— ভাদজিম
1
@ ভ্যাডজিম আমি নীচের কোডটি ব্যবহার করেছি যে Assert.assertEquals (রিফ্লেকশনটোস্ট্রিংবিল্ডার.টো স্ট্রিং (প্রত্যাশিত), রিফ্লেকশনটোস্ট্রিংবিল্ডার.টো স্ট্রিং (প্রকৃত)) পেতে;
— অভিজিৎ কুশে
2
গ্রাফের সমস্ত নোডের জন্য এটি "সমান" এবং "হ্যাশকোড" প্রয়োগ করে, যা মূলত এই পদ্ধতিটিকে প্রায় অকেজো করে তোলে। আসর্টজে'র ইকুয়ালটোকোম্পারিংফিল্ডবাইফিল্ডারসিভারসিভলি হ'ল আমার ক্ষেত্রে একদম সঠিকভাবে কাজ করা।
— জন জাং
12

আমি জানি এটি কিছুটা পুরানো, তবে আমি আশা করি এটি সাহায্য করবে।

আপনি যে সমস্যাটি পেয়ে গেছেন আমি তাই চালিয়েছি, সুতরাং তদন্তের পরে আমি এই প্রশ্নের চেয়ে কয়েকটি অনুরূপ প্রশ্ন পেয়েছি এবং সমাধানটি সন্ধান করার পরে, আমি সেগুলির মধ্যে একই উত্তর দিচ্ছি, যেহেতু আমি ভেবেছিলাম যে এটি অন্যদের সহায়তা করতে পারে।

এই অনুরূপ প্রশ্নের সর্বাধিক ভোট দেওয়া উত্তর (লেখকের দ্বারা নেওয়া নয়) আপনার জন্য সবচেয়ে উপযুক্ত সমাধান।

মূলত, এটি ইউনিটিলস নামে গ্রন্থাগারটি ব্যবহার করে ।

এটি ব্যবহার:

User user1 = new User(1, "John", "Doe");
User user2 = new User(1, "John", "Doe");
assertReflectionEquals(user1, user2);

যা ক্লাস Userবাস্তবায়ন না করলেও পাস করবে equals()। আপনি আরও উদাহরণ এবং assertLenientEqualsতাদের টিউটোরিয়ালে ডাকা একটি দুর্দান্ত দাবী দেখতে পারেন ।

— lopezvit
সূত্র
1
দুর্ভাগ্যক্রমে Unitilsমৃত্যুবরণ করা হয়েছে বলে মনে হয়, দেখুন স্ট্যাকওভারফ্লো / প্রশ্নগুলি / 34658067/is-unitils- প্রকল্প-alive ।
— কেন উইলিয়ামস
8

আপনি অ্যাপাচি কমন্স ল্যাং রিফ্লেকশনটোস্ট্রিংবিল্ডার ব্যবহার করতে পারেন

আপনি হয় একের পর এক পরীক্ষা করতে চান এমন বৈশিষ্ট্যগুলি নির্দিষ্ট করতে পারেন বা আরও ভাল, আপনি যা চান না তা বাদ দিন:

String s = new ReflectionToStringBuilder(o, ToStringStyle.SHORT_PREFIX_STYLE)
                .setExcludeFieldNames(new String[] { "foo", "bar" }).toString()

তারপরে আপনি দুটি স্ট্রিংটিকে স্বাভাবিক হিসাবে তুলনা করুন। প্রতিবিম্বটি ধীরে ধীরে হওয়ার জন্য, আমি ধরে নিই এটি কেবল পরীক্ষার জন্য, সুতরাং এত গুরুত্বপূর্ণ হওয়া উচিত নয়।

— ম্যাথিউ ফারওয়েল
সূত্র
1
এই পদ্ধতির অতিরিক্ত সুবিধা হ'ল আপনি যে ক্ষেত্রগুলিকে যত্নশীল না সেগুলি বাদ দিয়ে স্ট্রিং হিসাবে প্রত্যাশিত এবং আসল মানগুলি প্রদর্শন করার জন্য ভিজ্যুয়াল আউটপুট পাবেন।
— fquinner
7

আপনি যদি নিজের আসক্তির জন্য হ্যামক্রাস্ট ব্যবহার করছেন (assertThat) এবং অতিরিক্ত পরীক্ষার লিবিগুলিতে টানতে চান না, তবে আপনি SamePropertyValuesAs.samePropertyValuesAsযে আইটেমগুলিকে ওভাররাইড সমান পদ্ধতি নেই তা জোড় করে ব্যবহার করতে পারেন ।

উত্সাহটি হ'ল আপনাকে আর কোনও পরীক্ষার কাঠামোটি টানতে হবে না এবং যদি আপনি যদি এর মতো কিছু ব্যবহার করেন তবে expected: field=<value> but was field=<something else>পরিবর্তে দৃ the়তা ব্যর্থ ( ) ব্যর্থ হলে এটি একটি কার্যকর ত্রুটি দেবে ।expected: true but was falseEqualsBuilder.reflectionEquals()

অবক্ষয়টি হ'ল এটি একটি অগভীর তুলনা এবং ক্ষেত্রগুলি বাদ দেওয়ার কোনও বিকল্প নেই (যেমন সমতুল্য বিল্ডারে রয়েছে), সুতরাং আপনাকে নেস্টেড অবজেক্টগুলির চারপাশে কাজ করতে হবে (উদাহরণস্বরূপ এগুলি অপসারণ করুন এবং তাদের স্বাধীনভাবে তুলনা করুন)।

সর্বোত্তম ঘটনা:

import static org.hamcrest.beans.SamePropertyValuesAs.samePropertyValuesAs;
...
assertThat(actual, is(samePropertyValuesAs(expected)));

কুরুচিপূর্ণ মামলা:

import static org.hamcrest.beans.SamePropertyValuesAs.samePropertyValuesAs;
...
SomeClass expected = buildExpected(); 
SomeClass actual = sut.doSomething();

assertThat(actual.getSubObject(), is(samePropertyValuesAs(expected.getSubObject())));    
expected.setSubObject(null);
actual.setSubObject(null);

assertThat(actual, is(samePropertyValuesAs(expected)));

সুতরাং, আপনার বিষ বাছাই করুন। অতিরিক্ত কাঠামো (যেমন ইউনিটিলস), অকার্যকর ত্রুটি (উদাঃ সমতুল্য বিল্ডার), বা অগভীর তুলনা (হ্যামক্রেষ্ট)।

— বৃহৎ শিবির
সূত্র
1
কাজের জন্য প্রপার্টিভ্যালুস হিসাবে আপনার অবশ্যই প্রকল্প নির্ভরশীল হ্যামক্রিস্ট.আর
— জাভা
আমি এই সমাধানটি পছন্দ করি, কারণ এটি "সম্পূর্ণ * ভিন্ন অতিরিক্ত নির্ভরতা যোগ করে না!
— ঘোস্টটাগি
2

কিছু প্রতিবিম্ব তুলনা পদ্ধতি অগভীর

আরেকটি বিকল্প হ'ল বস্তুটিকে একটি জসনে রূপান্তর করা এবং স্ট্রিংগুলির সাথে তুলনা করা।

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;    
public static String getJsonString(Object obj) {
 try {
    ObjectMapper objectMapper = new ObjectMapper();
    return bjectMapper.writerWithDefaultPrettyPrinter().writeValueAsString(obj);
     } catch (JsonProcessingException e) {
        LOGGER.error("Error parsing log entry", e);
        return null;
    }
}
...
assertEquals(getJsonString(MyexpectedObject), getJsonString(MyActualObject))
— অব্রাহাম শালভ
সূত্র
2

শাজামক্রাস্ট ব্যবহার করে আপনি এটি করতে পারেন:

assertThat(obj1, sameBeanAs(obj2));
— লিওনেল সানচে দা সিলভা
সূত্র
হামজ্রেস্টের পরিবর্তে কেন শাজামক্রেস্ট ব্যবহার করবেন? stackoverflow.com/a/27817702/6648326
— MasterJoe
1
@ মাস্টারজো 2 আমার পরীক্ষায়, যখন বস্তুর বিভিন্ন উল্লেখ থাকে তখন reflectEqualsফিরে আসে false।
— লিওনেল সানচা দা সিলভা
1

মাঠের সাথে ক্ষেত্রের সাথে তুলনা করুন:

assertNotNull("Object 1 is null", obj1);
assertNotNull("Object 2 is null", obj2);
assertEquals("Field A differs", obj1.getFieldA(), obj2.getFieldA());
assertEquals("Field B differs", obj1.getFieldB(), obj2.getFieldB());
...
assertEquals("Objects are not equal.", obj1, obj2);
— EthanB
সূত্র
1
এটি এমন কিছু যা আমি করতে চাই না কারণ একটি প্রাথমিক দাবি ব্যর্থতা নীচে সম্ভাব্য ব্যর্থতাগুলি আড়াল করবে।
— রায়ান নেলসন
2
দুঃখিত, আমি আপনার পোস্টের সেই অংশটি মিস করেছি ... ইউনিট-পরীক্ষার পরিবেশে কেন "পূর্ণ সমতা চিত্র" গুরুত্বপূর্ণ? হয় ক্ষেত্রগুলি সমস্ত সমান (পরীক্ষার পাস), বা সেগুলি সব সমান নয় (পরীক্ষায় ব্যর্থ হয়)।
— ইথানবি
অন্যান্য ক্ষেত্রগুলি সমান নয় কিনা তা আবিষ্কার করতে আমি আবার পরীক্ষা চালাতে চাই না। আমি অসম ক্ষেত্রের সমস্ত ক্ষেত্রগুলি জানতে চাই যাতে আমি তাদের একবারে সম্বোধন করতে পারি।
— রায়ান নেলসন
1
এক পরীক্ষায় অনেকগুলি ক্ষেত্র যুক্ত করা সত্য 'ইউনিট' পরীক্ষা বলে বিবেচিত হবে না। Traditionalতিহ্যগত পরীক্ষা-চালিত বিকাশ (টিডিডি) দিয়ে আপনি একটি ছোট পরীক্ষা লিখেছেন এবং তারপরে এটি পাস করার জন্য কেবল পর্যাপ্ত কোড রয়েছে। প্রতি ক্ষেত্রের জন্য একটি দৃsert় পদক্ষেপ নেওয়া এটি করার সঠিক উপায়, কেবল সমস্ত পরীক্ষাকে একটি পরীক্ষায় রাখবেন না। আপনার যত্ন নেওয়া প্রতিটি ক্ষেত্রের দৃser়তার জন্য আলাদা পরীক্ষা তৈরি করুন। এটি আপনাকে স্যুটের একক রান দিয়ে সমস্ত ক্ষেত্রের সমস্ত ত্রুটি দেখতে দেয়। যদি এটি শক্ত হয় তবে এর অর্থ সম্ভবত আপনার কোডটি প্রথম স্থানে পর্যাপ্ত পরিমাণে মডুলার নয় এবং সম্ভবত একটি পরিষ্কার সমাধানে রিফ্যাক্টর করা যেতে পারে।
— জেসি ওয়েব
এটি অবশ্যই একটি বৈধ পরামর্শ এবং আপনি একক পরীক্ষায় একাধিক সংস্থান সমাধান করার স্বাভাবিক উপায়। এখানে একমাত্র চ্যালেঞ্জটি হ'ল, আমি বস্তুর সামগ্রিক দৃষ্টিভঙ্গি চাই। অর্থাৎ, আমি অবজেক্টটি বৈধ অবস্থায় রয়েছে কিনা তা যাচাই করতে একসাথে সমস্ত ক্ষেত্র পরীক্ষা করতে চাই। আপনার যখন ওভাররাইড সমান () পদ্ধতি (অবশ্যই এই উদাহরণটিতে আমার নেই) তখন এটি করা কঠিন নয়।
— রায়ান নেলসন
1

AssertJ assertions #equalsপদ্ধতি ছাড়া সঠিকভাবে ওভাররাইড করা মানগুলি তুলনা করতে ব্যবহার করা যেতে পারে , যেমন:

import static org.assertj.core.api.Assertions.assertThat; 

// ...

assertThat(actual)
    .usingRecursiveComparison()
    .isEqualTo(expected);
— পাভেল
সূত্র
1

যেহেতু এই প্রশ্নটি পুরানো, আমি JUnit 5 ব্যবহার করে আরও একটি আধুনিক পদ্ধতির পরামর্শ দেব।

আমি এই সমাধানটি পছন্দ করি না কারণ প্রথম দিকের প্রতিবেদন ব্যর্থ হলে আমি সম্পূর্ণ সমতা চিত্র পাই না don't

JUnit 5 এর সাথে, এমন একটি পদ্ধতি বলা হয়েছে Assertions.assertAll()যা আপনাকে পরীক্ষার সমস্ত যুক্তি একসাথে গোষ্ঠী করতে দেয় এবং এটি প্রতিটিটি কার্যকর করে এবং শেষে কোনও ব্যর্থ প্রতিবেদনের ফলাফল দেয়। এর অর্থ হ'ল যে ব্যর্থতা যেগুলি প্রথমে ব্যর্থ হয় তা পরবর্তীকালের দাবিগুলি কার্যকর করা বন্ধ করবে না।

assertAll("Test obj1 with obj2 equality",
    () -> assertEquals(obj1.getFieldA(), obj2.getFieldA()),
    () -> assertEquals(obj1.getFieldB(), obj2.getFieldB()),
    () -> assertEquals(obj1.getFieldC(), obj2.getFieldC()));
— patelb
সূত্র
0

সম্পূর্ণ সমতা পরীক্ষার "স্বয়ংক্রিয়" করতে আপনি প্রতিবিম্বটি ব্যবহার করতে পারেন। আপনি একক ক্ষেত্রের জন্য লিখেছেন সেই সমতা "ট্র্যাকিং" কোডটি প্রয়োগ করতে পারেন, তারপরে অবজেক্টটির সমস্ত ক্ষেত্রে এই পরীক্ষাটি চালানোর জন্য প্রতিচ্ছবি ব্যবহার করুন।

— jtahlborn
সূত্র
0

এটি একটি জেনেরিক তুলনা পদ্ধতি, যা ক্ষেত্রের মানগুলির জন্য একই শ্রেণীর দুটি বস্তুর তুলনা করে (মনে রাখবেন যে এগুলি পদ্ধতিটির মাধ্যমে অ্যাক্সেসযোগ্য রয়েছে)

public static <T> void compare(T a, T b) throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {
    AssertionError error = null;
    Class A = a.getClass();
    Class B = a.getClass();
    for (Method mA : A.getDeclaredMethods()) {
        if (mA.getName().startsWith("get")) {
            Method mB = B.getMethod(mA.getName(),null );
            try {
                Assert.assertEquals("Not Matched = ",mA.invoke(a),mB.invoke(b));
            }catch (AssertionError e){
                if(error==null){
                    error = new AssertionError(e);
                }
                else {
                    error.addSuppressed(e);
                }
            }
        }
    }
    if(error!=null){
        throw error ;
    }
}
— শান্তনু
সূত্র
0

আমি খুব অনুরূপ ক্ষেত্রে হোঁচট খেয়েছি।

আমি একটি পরীক্ষায় তুলনা করতে যে একটি বস্তু অন্য এক হিসাবে একই বৈশিষ্ট্য মান ছিল চেয়েছিলেন, কিন্তু মত পদ্ধতি is(), refEq()ইত্যাদি would একটি নাল মান আমার বস্তুর মত কারণের জন্য কাজ না তারid অ্যাট্রিবিউট।

সুতরাং এটিই আমি পেয়েছি সমাধান (ভাল, সহকর্মী পাওয়া গেছে):

import static org.apache.commons.lang.builder.CompareToBuilder.reflectionCompare;

assertThat(reflectionCompare(expectedObject, actualObject, new String[]{"fields","to","be","excluded"}), is(0));

যদি প্রাপ্ত মান reflectionCompare0 হয় তবে এর অর্থ তারা সমান। যদি এটি -1 বা 1 হয় তবে তারা কিছু বৈশিষ্ট্যের সাথে পৃথক হয়।

— cavpollo
সূত্র
0

AssertJ এর ক্ষেত্রে সাধারণ ক্ষেত্রে আপনি কাস্টম তুলনামূলক কৌশল তৈরি করতে পারেন:

assertThat(frodo).usingComparator(raceComparator).isEqualTo(sam)
assertThat(fellowshipOfTheRing).usingElementComparator(raceComparator).contains(sauron);

জোর দিয়ে কাস্টম তুলনা কৌশল ব্যবহার

AssertJ উদাহরণ

— গ্রিগরি কিসলিন
সূত্র
0

ইউনিট অ্যান্ড্রয়েড অ্যাপ্লিকেশন পরীক্ষা করার সময় আমার ঠিক একই ধরণের ঝাঁকুনি ছিল এবং আমি যে সহজ সমাধানটি নিয়ে এসেছি তা হ'ল আমার আসল এবং প্রত্যাশিত মান আইটেমগুলিকে রূপান্তর করতে jsonএবং স্ট্রিং হিসাবে তাদের তুলনা করার জন্য গসনকে ব্যবহার করা ।

String actual = new Gson().toJson( myObj.getValues() );
String expected = new Gson().toJson( new MyValues(true,1) );

assertEquals(expected, actual);

ক্ষেত্রের সাথে ক্ষেত্রের সাথে ম্যানুয়ালি তুলনা করার পক্ষে এর সুবিধাগুলি হ'ল আপনি আপনার সমস্ত ক্ষেত্রের তুলনা করুন , সুতরাং পরে আপনি যদি নিজের ক্লাসে একটি নতুন ক্ষেত্র যুক্ত করেন তবে এটি স্বয়ংক্রিয়ভাবে পরীক্ষিত হবে, আপনি যদি একগুচ্ছ গুচ্ছ ব্যবহার করে যাচ্ছেন তার তুলনায়assertEquals() উপর আপনি যদি আপনার শ্রেণিতে আরও ক্ষেত্র যুক্ত করেন তবে সমস্ত ক্ষেত্রগুলি আপডেট করা দরকার।

jUnit এছাড়াও আপনার জন্য স্ট্রিংগুলি প্রদর্শন করে যাতে আপনি সরাসরি দেখতে পাবেন যেগুলি সেগুলির চেয়ে আলাদা। ফিল্ড অর্ডার করা কতটা নির্ভরযোগ্য তা নিশ্চিত না Gsonহলেও এটি একটি সম্ভাব্য সমস্যা হতে পারে।

— ম্যাগনাস ডাব্লু
সূত্র
1
ফিল্ডস অর্ডার জেসন দ্বারা গ্যারান্টিযুক্ত নয়। আপনি স্ট্রিংগুলি জাসন পার্স করতে এবং পার্সিংয়ের ফলে প্রাপ্ত জসনএলিমেন্টের তুলনা করতে চাইতে পারেন
— ওজমা
0

আমি সমস্ত উত্তর চেষ্টা করেছিলাম এবং কিছুই সত্যিই আমার পক্ষে কাজ করে না।

সুতরাং আমি আমার নিজস্ব পদ্ধতি তৈরি করেছি যা নীড়ের কাঠামোর গভীরে না গিয়ে সহজ জাভা সামগ্রীর সাথে তুলনা করে ...

সমস্ত ক্ষেত্রের সাথে মেলে বা মেলে না এমন মেলে না এমন বিশদ সম্পর্কিত পদ্ধতি যদি পদ্ধতি বাতিল হয়।

কেবলমাত্র গিটার পদ্ধতিযুক্ত বৈশিষ্ট্যগুলির সাথে তুলনা করা হয়।

ব্যবহারবিধি

        assertNull(TestUtils.diff(obj1,obj2,ignore_field1, ignore_field2));

কোনও মিল নেই তবে নমুনা আউটপুট

আউটপুট সম্পত্তির নাম এবং তুলনামূলক অবজেক্টগুলির স্ব স্ব মান দেখায়

alert_id(1:2), city(Moscow:London)

কোড (জাভা 8 এবং উপরে):

 public static String diff(Object x1, Object x2, String ... ignored) throws Exception{
        final StringBuilder response = new StringBuilder();
        for (Method m:Arrays.stream(x1.getClass().getMethods()).filter(m->m.getName().startsWith("get")
        && m.getParameterCount()==0).collect(toList())){

            final String field = m.getName().substring(3).toLowerCase();
            if (Arrays.stream(ignored).map(x->x.toLowerCase()).noneMatch(ignoredField->ignoredField.equals(field))){
                Object v1 = m.invoke(x1);
                Object v2 = m.invoke(x2);
                if ( (v1!=null && !v1.equals(v2)) || (v2!=null && !v2.equals(v1))){
                    response.append(field).append("(").append(v1).append(":").append(v2).append(")").append(", ");
                }
            }
        }
        return response.length()==0?null:response.substring(0,response.length()-2);
    }
— স্টান সোকোলভ
সূত্র
0

শুধুমাত্র জুনিট-এর বিকল্প হিসাবে, সমান সমীকরণের আগে আপনি ক্ষেত্রগুলি শূন্য করতে পারেন:

    actual.setCreatedDate(null); // excludes date assertion
    expected.setCreatedDate(null);

    assertEquals(expected, actual);
— অ্যান্ড্রু তারান
সূত্র
-1

আপনি কিছু স্থিতিশীল ইউটিলিটি পদ্ধতিতে পোস্ট করা তুলনা কোডটি রাখতে পারেন?

public static String findDifference(Type obj1, Type obj2) {
    String difference = "";
    if (obj1.getFieldA() == null && obj2.getFieldA() != null
            || !obj1.getFieldA().equals(obj2.getFieldA())) {
        difference += "Difference at field A:" + "obj1 - "
                + obj1.getFieldA() + ", obj2 - " + obj2.getFieldA();
    }
    if (obj1.getFieldB() == null && obj2.getFieldB() != null
            || !obj1.getFieldB().equals(obj2.getFieldB())) {
        difference += "Difference at field B:" + "obj1 - "
                + obj1.getFieldB() + ", obj2 - " + obj2.getFieldB();
        // (...)
    }
    return difference;
}

আপনি JUnit এ এই পদ্ধতিটি ব্যবহার করতে পারেন তার চেয়ে:

assertEquals ("অবজেক্ট সমান নয়", "", FindDifferences (obj1, আপত্তি));

যা চতুর নয় এবং পার্থক্য সম্পর্কে সম্পূর্ণ তথ্য দেয়, যদি সেগুলি বিদ্যমান থাকে (সাধারণ আকার হিসাবে একেবারেই নয় তবে আপনি সমস্ত তথ্য পান যাতে এটি ভাল হওয়া উচিত)।

— কামিল
সূত্র
-1

এটি ওপিকে সহায়তা করবে না, তবে এটি এখানে শেষ হওয়া কোনও সি # বিকাশকারীকে সহায়তা করতে পারে ...

মত এনরিক পোস্ট করেছেন , আপনার সমান পদ্ধতিটি ওভাররাইড করা উচিত।

সাবক্ল্যাসিং এবং ওভাররাইডিং ইকুয়াল (উঘ) ছাড়াই অবজেক্ট থেকে আমি যা চাই তা পাওয়ার কি আরও ভাল অনুশীলন আছে?

আমার পরামর্শটি সাবক্লাস ব্যবহার না করা। একটি আংশিক বর্গ ব্যবহার করুন।

আংশিক শ্রেণীর সংজ্ঞা (এমএসডিএন)

আপনার ক্লাসটি দেখতে দেখতে ...

public partial class TheClass
{
    public override bool Equals(Object obj)
    {
        // your implementation here
    }
}

জাভার জন্য, আমি প্রতিবিম্বটি ব্যবহার করার পরামর্শের সাথে একমত হব। কেবল মনে রাখবেন যে যখনই সম্ভব প্রতিচ্ছবি ব্যবহার করা আপনার এড়ানো উচিত। এটি ধীর, ডিবাগ করা শক্ত এবং ভবিষ্যতে বজায় রাখা আরও শক্ত কারণ আইডিইগুলি আপনার ক্ষেত্রের নাম পরিবর্তন করে বা এর মতো কিছু করে আপনার কোডটি ভেঙে দিতে পারে। সতর্ক হোন!

— জেসি ওয়েব
সূত্র
-1

আপনার মন্তব্যগুলি থেকে অন্যান্য উত্তরগুলিতে, আপনি কী চান তা আমি বুঝতে পারি না।

কেবল আলোচনার খাতিরে, বলতে পারি যে শ্রেণিটি সমান পদ্ধতিটিকে ওভাররাইড করে।

সুতরাং আপনার UT এর মতো দেখতে পাবেন:

SomeType expected = // bla
SomeType actual = // bli

Assert.assertEquals(expected, actual).

এবং আপনি সম্পন্ন হয়েছে। তদ্ব্যতীত, দৃser়তা ব্যর্থ হলে আপনি "সম্পূর্ণ সমতা চিত্র" পেতে পারেন না।

আমি যা বুঝি সেগুলি থেকে আপনি বলছেন যে প্রকারটি সমানভাবে ওভাররাইড করলেও আপনি তাতে আগ্রহী হবেন না, যেহেতু আপনি "সম্পূর্ণ সমতা চিত্র" পেতে চান want সুতরাং সমান বাড়াতে এবং ওভাররাইড করার কোনও মানে নেই।

সুতরাং আপনার বিকল্পগুলি রয়েছে: হয় সম্পত্তি দ্বারা সম্পত্তিটির তুলনা করুন, প্রতিবিম্ব বা হার্ড-কোডেড চেক ব্যবহার করে, আমি পরবর্তীগুলির পরামর্শ দেব। বা: মানব পাঠযোগ্য উপস্থাপনা তুলনা করুন এই বস্তুর ।

উদাহরণস্বরূপ, আপনি একটি সহায়ক শ্রেণি তৈরি করতে পারেন যা কোনও এক্সএমএল ডকুমেন্টের সাথে তুলনা করতে চান ফলাফলটি এবং এক্সএমএল তুলনায় তুলনামূলক তুলনা করুন! এই ক্ষেত্রে, আপনি চাক্ষুষভাবে দেখতে পারবেন ঠিক কি সমান এবং কোনটি নয়।

এই পদ্ধতির আপনাকে পুরো ছবিটি দেখার সুযোগ দেবে তবে এটি তুলনামূলকভাবে জটিল (এবং প্রথমে কিছুটা ত্রুটিযুক্ত)।

— Vitaliy
সূত্র
আমার শব্দ "সম্পূর্ণ সমতা চিত্র" বিভ্রান্তিকর সম্ভব। সমান () বাস্তবায়ন করা সমস্যার সমাধান করবে। আমি একই সাথে সমস্ত অসম ক্ষেত্র (সমতার সাথে প্রাসঙ্গিক) জানতে আগ্রহী, ডাব্লু / ও পরীক্ষাটি আবার চালাতে হবে। অবজেক্টটি সিরিয়াল করা অন্য সম্ভাবনা, তবে অগত্যা আমার গভীর সমতার দরকার নেই। আমি যদি সম্ভব হয় তবে সম্পত্তিগুলির সমান () বাস্তবায়ন কাজে লাগাতে চাই।
— রায়ান নেলসন
গ্রেট! আপনি আপনার সম্পত্তির সমতুল্যকে পুরোপুরি ব্যবহার করতে পারেন, যেমন আপনি আপনার প্রশ্নে বলেছেন stated দেখে মনে হচ্ছে এটি এই ক্ষেত্রে সর্বাধিক সরল সমাধান তবে আপনি উল্লেখ করেছেন যে কোডটি খুব খারাপ লাগবে।
— ভাইটালিয়
-3

আপনি ক্লাসের সমান পদ্ধতিটি ওভাররাইড করতে পারেন:

@Override
public int hashCode() {
    int hash = 0;
    hash += (app != null ? app.hashCode() : 0);
    return hash;
}

@Override
public boolean equals(Object object) {
    HubRule other = (HubRule) object;

    if (this.app.equals(other.app)) {
        boolean operatorHubList = false;

        if (other.operator != null ? this.operator != null ? this.operator
                .equals(other.operator) : false : true) {
            operatorHubList = true;
        }

        if (operatorHubList) {
            return true;
        } else {
            return false;
        }
    } else {
        return false;
    }
}

ঠিক আছে, আপনি যদি একটি শ্রেণি থেকে দুটি বস্তুর তুলনা করতে চান তবে আপনাকে অবশ্যই কোনও উপায়ে সমান এবং হ্যাশ কোড পদ্ধতি প্রয়োগ করতে হবে

— এনরিক সান মার্টন
সূত্র
3
তবে ওপি বলেছে যে সে সমানকে ওভাররাইড করতে চায় না, সে আরও ভাল পথ চায়
— অঙ্কুর
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.