SORU
21 EYLÜL 2011, ÇARŞAMBA


Nasıl Ayar değil saplama somut uygulamaları olan soyut bir sınıf söylemek

Ayar kodu test etmek için kullanmaya çalışıyorum. Dört beton uygulamaları ile soyut bir sınıf var. Dört beton tipleri için fabrika yöntemleri oluşturduk. Ayrıca soyut fabrika yöntemi kullanmaz Ayar soyut türü this nice thread açıkladığı gibi, dışında, bir ben yarattım, ne de gerekir.

Asıl sorun bazı kodumu bağlı dört beton türleri olmak vardır (bu çok, çok zor artık alt sınıflar oluşturulacak) ama Ayar olur kırma kodunu kullanarak Benler oluşturmak için bir saplama.

Nasıl fabrika yöntemleri (herhangi biri umrumda değil) hiç biri Benler koçanları soyut sınıf oluşturma olmadan soyut sınıf örneği oluşturmak için kullanılacak Ayar zorlayabilir miyim? Bunu gerçekleştirmek olacak PexAssume bir Direktif var mı? Beton türleri bazı ağaç yapısı, tipi ve formu, yani ConcreteImplementation* *4 ve ConcreteImplementation kaynaklanıyor ki unutmayın türden iki özellikleri AbstractClass vardır. Hayır koçanları her yerde ağaç hiç alışık olmak lazım. (Tüm beton uygulamaları AbstractClass özellikleri vardır.)

Düzenleme:

Kendisi çalışır sınıf yapısı, amaç saplama sınıflar için Ayar nasıl hala hatırlıyorum ama hakkında biraz daha bilgi eklemek için ihtiyacım var gibi görünüyor.

Burada soyut temel sınıf ve dört beton uygulamaları bunların basitleştirilmiş versiyonu.

public abstract class AbstractClass
{
    public abstract AbstractClass Distill();

    public static bool operator ==(AbstractClass left, AbstractClass right)
    {
         // some logic that returns a bool
    }

    public static bool operator !=(AbstractClass left, AbstractClass right)
    {
         // some logic that basically returns !(operator ==)
    }

    public static Implementation1 Implementation1
    {
        get
        {
            return Implementation1.GetInstance;
        }
    }
}

public class Implementation1 : AbstractClass, IEquatable<Implementation1>
{
    private static Implementation1 _implementation1 = new Implementation1();

    private Implementation1()
    {
    }

    public override AbstractClass Distill()
    {
        return this;
    }

    internal static Implementation1 GetInstance
    {
        get
        {
            return _implementation1;
        }
    }

    public bool Equals(Implementation1 other)
    {
        return true;
    }
}

public class Implementation2 : AbstractClass, IEquatable<Implementation2>
{
    public string Name { get; private set; }
    public string NamePlural { get; private set; }

    public Implementation2(string name)
    {
        // initializes, including
        Name = name;
        // and sets NamePlural to a default
    }

    public Implementation2(string name, string plural)
    {
        // initializes, including
        Name = name;
        NamePlural = plural;
    }

    public override AbstractClass Distill()
    {
        if (String.IsNullOrEmpty(Name))
        {
            return AbstractClass.Implementation1;
        }
        return this;
    }

    public bool Equals(Implementation2 other)
    {
        if (other == null)
        {
            return false;
        }

        return other.Name == this.Name;
    }
}

public class Implementation3 : AbstractClass, IEquatable<Implementation3>
{
    public IEnumerable<AbstractClass> Instances { get; private set; }

    public Implementation3()
        : base()
    {
        Instances = new List<AbstractClass>();
    }

    public Implementation3(IEnumerable<AbstractClass> instances)
        : base()
    {
        if (instances == null)
        {
            throw new ArgumentNullException("instances", "error msg");
        }

        if (instances.Any<AbstractClass>(c => c == null))
        {
            thrown new ArgumentNullException("instances", "some other error msg");
        }

        Instances = instances;
    }

    public override AbstractClass Distill()
    {
        IEnumerable<AbstractClass> newInstances = new List<AbstractClass>(Instances);

        // "Flatten" the collection by removing nested Implementation3 instances
        while (newInstances.OfType<Implementation3>().Any<Implementation3>())
        {
            newInstances = newInstances.Where<AbstractClass>(c => c.GetType() != typeof(Implementation3))
                                       .Concat<AbstractClass>(newInstances.OfType<Implementation3>().SelectMany<Implementation3, AbstractUnit>(i => i.Instances));
        }

        if (newInstances.OfType<Implementation4>().Any<Implementation4>())
        {
            List<AbstractClass> denominator = new List<AbstractClass>();

            while (newInstances.OfType<Implementation4>().Any<Implementation4>())
            {
                denominator.AddRange(newInstances.OfType<Implementation4>().Select<Implementation4, AbstractClass>(c => c.Denominator));
                newInstances = newInstances.Where<AbstractClass>(c => c.GetType() != typeof(Implementation4))
                                           .Concat<AbstractClass>(newInstances.OfType<Implementation4>().Select<Implementation4, AbstractClass>(c => c.Numerator));
            }

            return (new Implementation4(new Implementation3(newInstances), new Implementation3(denominator))).Distill();
        }

        // There should only be Implementation1 and/or Implementation2 instances
        // left.  Return only the Implementation2 instances, if there are any.
        IEnumerable<Implementation2> i2s = newInstances.Select<AbstractClass, AbstractClass>(c => c.Distill()).OfType<Implementation2>();
        switch (i2s.Count<Implementation2>())
        {
            case 0:
                return AbstractClass.Implementation1;
            case 1:
                return i2s.First<Implementation2>();
            default:
                return new Implementation3(i2s.OrderBy<Implementation2, string>(c => c.Name).Select<Implementation2, AbstractClass>(c => c));
        }
    }

    public bool Equals(Implementation3 other)
    {
        // omitted for brevity
        return false;
    }
}

public class Implementation4 : AbstractClass, IEquatable<Implementation4>
{
    private AbstractClass _numerator;
    private AbstractClass _denominator;

    public AbstractClass Numerator
    {
        get
        {
            return _numerator;
        }

        set
        {
            if (value == null)
            {
                throw new ArgumentNullException("value", "error msg");
            }

            _numerator = value;
        }
    }

    public AbstractClass Denominator
    {
        get
        {
            return _denominator;
        }

        set
        {
            if (value == null)
            {
                throw new ArgumentNullException("value", "error msg");
            }
            _denominator = value;
        }
    }

    public Implementation4(AbstractClass numerator, AbstractClass denominator)
        : base()
    {
        if (numerator == null || denominator == null)
        {
            throw new ArgumentNullException("whichever", "error msg");
        }

        Numerator = numerator;
        Denominator = denominator;
    }

    public override AbstractClass Distill()
    {
        AbstractClass numDistilled = Numerator.Distill();
        AbstractClass denDistilled = Denominator.Distill();

        if (denDistilled.GetType() == typeof(Implementation1))
        {
            return numDistilled;
        }
        if (denDistilled.GetType() == typeof(Implementation4))
        {
            Implementation3 newInstance = new Implementation3(new List<AbstractClass>(2) { numDistilled, new Implementation4(((Implementation4)denDistilled).Denominator, ((Implementation4)denDistilled).Numerator) });
            return newInstance.Distill();
        }
        if (numDistilled.GetType() == typeof(Implementation4))
        {
            Implementation4 newImp4 = new Implementation4(((Implementation4)numReduced).Numerator, new Implementation3(new List<AbstractClass>(2) { ((Implementation4)numDistilled).Denominator, denDistilled }));
            return newImp4.Distill();
        }

        if (numDistilled.GetType() == typeof(Implementation1))
        {
            return new Implementation4(numDistilled, denDistilled);
        }

        if (numDistilled.GetType() == typeof(Implementation2) && denDistilled.GetType() == typeof(Implementation2))
        {
            if (((Implementation2)numDistilled).Name == (((Implementation2)denDistilled).Name)
            {
                return AbstractClass.Implementation1;
            }
            return new Implementation4(numDistilled, denDistilled);
        }

        // At this point, one or both of numerator and denominator are Implementation3
        // instances, and the other (if any) is Implementation2.  Because both
        // numerator and denominator are distilled, all the instances within either
        // Implementation3 are going to be Implementation2.  So, the following should
        // work.
        List<Implementation2> numList =
            numDistilled.GetType() == typeof(Implementation2) ? new List<Implementation2>(1) { ((Implementation2)numDistilled) } : new List<Implementation2>(((Implementation3)numDistilled).Instances.OfType<Implementation2>());

        List<Implementation2> denList =
            denDistilled.GetType() == typeof(Implementation2) ? new List<Implementation2>(1) { ((Implementation2)denDistilled) } : new List<Implementation2>(((Implementation3)denDistilled).Instances.OfType<Implementation2>());

        Stack<int> numIndexesToRemove = new Stack<int>();
        for (int i = 0; i < numList.Count; i  )
        {
            if (denList.Remove(numList[i]))
            {
                numIndexesToRemove.Push(i);
            }
        }

        while (numIndexesToRemove.Count > 0)
        {
            numList.RemoveAt(numIndexesToRemove.Pop());
        }

        switch (denList.Count)
        {
            case 0:
                switch (numList.Count)
                {
                    case 0:
                        return AbstractClass.Implementation1;
                    case 1:
                        return numList.First<Implementation2>();
                    default:
                        return new Implementation3(numList.OfType<AbstractClass>());
                }
            case 1:
                switch (numList.Count)
                {
                    case 0:
                        return new Implementation4(AbstractClass.Implementation1, denList.First<Implementation2>());
                    case 1:
                        return new Implementation4(numList.First<Implementation2>(), denList.First<Implementation2>());
                    default:
                        return new Implementation4(new Implementation3(numList.OfType<AbstractClass>()), denList.First<Implementation2>());
                }
            default:
                switch (numList.Count)
                {
                    case 0:
                        return new Implementation4(AbstractClass.Implementation1, new Implementation3(denList.OfType<AbstractClass>()));
                    case 1:
                        return new Implementation4(numList.First<Implementation2>(), new Implementation3(denList.OfType<AbstractClass>()));
                    default:
                        return new Implementation4(new Implementation3(numList.OfType<AbstractClass>()), new Implementation3(denList.OfType<AbstractClass>()));
                }
        }
    }

    public bool Equals(Implementation4 other)
    {
        return Numerator.Equals(other.Numerator) && Denominator.Equals(other.Denominator);
    }
}

Test etmeye çalışıyorum ne kalp gördüğünüz gibi özyinelemeli olarak çalışma potansiyeline sahip olan Distill yöntemidir. AbstractClass. Bu paradigma anlamsız olduğu için, algoritma mantığını kırıyor. Bir saplama bir sınıf için test etmeye küçük olduğundan biraz işe yaramaz, hatta bu konuda bir istisna veya Implementation1 bir örneği olduğunu iddia dışında yapabileceğim. Tercih ederim yok etmek için yeniden kod altında test karşılamak için belirli bir test çerçevesi içinde öyle, ama yazılı sınavda böyle bir şekilde asla saplama AbstractClass ne yapmaya çalışıyorum burada.

Ben ne yapıyorum tip-güvenli bir sıralama yap mesela ne kadar farklı olduğunu açıktır umarım. Ayrıca, anonim nesneler için burada gönderme (bu gibi söyle) ve ben değil tüm yöntemleri vardır, bu yüzden eğer yorum yapmak söyle bana Implementation4.Equals(Implementation4) kırık, merak etme, bunun farkındayım kırıcak burada, ama benim gerçek kod ilgileniyor konuyla.

Başka bir edit:

Burada fabrika sınıfların bir örneği. Ayar tarafından oluşturulan projesinin Fabrikaları dizininde.

public static partial class Implementation3Factory
{
    [PexFactoryMethod(typeof(Implementation3))]
    public static Implementation3 Create(IEnumerable<AbstractClass> instances, bool useEmptyConstructor)
    {
        Implementation3 i3 = null;
        if (useEmptyConstructor)
        {
            i3 = new Implementation3();
        }
        else
        {
            i3 = new Implementation3(instances);
        }

        return i3;
    }
}

Bu beton uygulamaları için fabrika yöntemlerimi, beton uygulaması oluşturmak için herhangi bir yapıcı kullanmak mümkündür. Bu örnekte, useEmptyConstructor parametre kullanmak için hangi kontrol eder. Diğer fabrika yöntemleri benzer özelliklere sahip. Bu fabrika yöntemleri nesne her türlü konfigürasyon oluşturulur gereken hemen linki bulamıyorum ama okuma hatırlıyorum,,.

CEVAP
29 AĞUSTOS 2014, Cuma


Ben çok iyi bir araç bulmak için geliyor: HiveRunner. JUnit üst kovanı komut test etmek için çerçeve. Bu başlık altında bir stand yalnız metastore olarak HiveServer bellek tutmak için kullanılır ile başlıyor.

Bunu Paylaş:
  • Google+
  • E-Posta
Etiketler:

YORUMLAR

SPONSOR VİDEO

Rastgele Yazarlar

  • Fr. Eckle Studios

    Fr. Eckle St

    29 Kasım 2006
  • Jay Will

    Jay Will

    19 NİSAN 2006
  • Missouri Star Quilt Company

    Missouri Sta

    18 ŞUBAT 2009