أكثر

هل يتسبب أي شيء متعلق بـ Python في تعطل ArcGIS for Desktop؟

هل يتسبب أي شيء متعلق بـ Python في تعطل ArcGIS for Desktop؟


مشكلة: يتعطل ArcMap 10.3 على سطح المكتب في أي وقت أستخدم فيه وظيفة مرتبطة ببيثون (Toolboxes ، Field Calulator ، إلخ)

كيف وصلت إلى هذه النقطة: كنت أحاول اكتساب بعض الإلمام ببرمجة بايثون واخترت استخدام دليل Learn Python The Hard Way.
تضمن ذلك تنزيل Python وتثبيته وإعداد بيئتك باستخدام Powershell.
أعتقد أن هذا تسبب في بعض المشكلات نظرًا لوجود تثبيت Python بالفعل من تثبيت ArcGIS. كان هناك بالفعل مجلد "Python27" على محرك الأقراص الثابتة الرئيسي.

سؤال: كيف يمكنني إخبار ArcMap بالبحث في المجلد "Python27 ArcGIS10.3" الخاص ببايثون؟ أفضل تجنب إعادة تثبيت ArcGIS بالكامل.

لقطات للفكر:

^ من البحث الأولي ، وجدت أنه يجب أن يكون لديّ نوع من دليل Python يتم إدخاله في هذه الحقول ، لكنني لست متأكدًا مما يحتاج تحديدًا للذهاب إلى هناك.


لحل المشكلة ، قمت بما يلي:

  • تم حذف عمليات التثبيت / مثيلات Python الإضافية خارج مجلد ArcGIS10.3 الخاص بي.
  • أعد ضبط بيئتي باتباع الخطوات الواردة في "تعلم بايثون بالطريقة الصعبة" بإخبارها بالبحث في "Python27 ArcGIS10.3"
  • استخدم "برنامج الإصلاح" من تطبيق الإعداد داخل المجلد الرئيسي لـ ArcGIS Desktop

يبدو أن الأمور مستقرة وتعمل الآن.


PyQt5 - تؤدي تغييرات Palette / StyleSheet إلى تعطل البرنامج باستخدام eventFilter

كنت أحاول تقليد آلة حاسبة Windows باستخدام PyQt5. لقد وصلت إلى نقطة احتجت فيها إلى تغيير لون النص الموجود على QLabel الذي أستخدمه كحدود نافذة مخصصة (للسماح بأشياء مثل الشفافية).

لقد بدأت بتجربة أشياء مثل QEvent و eventFilter وباستخدام طرق مثل isActiveWindow لمحاولة التبديل بين ظلال الأسود وبين اللون الشفاف وغير الشفاف.

عند القيام بذلك ، تمكنت من الوصول إلى مرحلة تتغير فيها الخلفية تمامًا ، ولكن في اللحظة التي أحاول فيها إضافة QLabel / Text إلى المزيج ، يتعطل البرنامج في نقاط مختلفة. لم أتمكن حتى وقت الكتابة من معرفة مكان أو سبب استخدام وحدة التحكم فقط يطبع "انتهت العملية برمز الخروج -1073740791 (0xC0000409)".

أيضًا ، لم أجد أي شيء واضح لمعرفي وخبرتي الحالية حول سبب حدوث ذلك. حتى الآن ، خذلني YouTube و Google ومحتوى StackOverflow الحالي. :(

يرجى مراعاة أنني جديد للغاية في البرمجة و Python وأكثر من ذلك PyQt5.


إذا كان المستخدم يتحكم في اسم الملف ، فقد تنفتح على نقاط الضعف (على سبيل المثال ، قد يحاول المهاجم قراءة ملفات التكوين باستخدام كلمة مرور قاعدة البيانات). لكن مجرد فتح مقبض ملف لملف تم تحميله لا يمكن أن يفعل الكثير.

ربما إذا حاولت الآلية الأساسية قراءة الملف بأكمله لأغراض التخزين المؤقت ، فقد تملأ ذاكرة الوصول العشوائي وتعطل العملية ، لكن بايثون لا تفعل ذلك: لقراءة الملف بأكمله ، يجب عليك أولاً استدعاء f.read ( ) - ولكن هذا فقط ما تفعله به ، وليس فتح الملف. فقط فتح الملف غير ضار.

تحتوي أنظمة التشغيل بشكل عام على عدد محدود من الملفات التي يمكن فتحها مرة واحدة (على وجه التحديد ، عدد محدود من واصفات الملفات أو fd s في أنظمة تشبه Unix ، أو HANDLE s في Windows). إذا سمحت للأشخاص بفتح عدد تعسفي من هؤلاء دون إغلاقهم ، فقد يكون من الممكن استنفاد هذا الحد ، مما قد يمنع نظام التشغيل من فتح المزيد من الملفات وربما يتسبب في سوء تصرفه أو حتى تعطله. سيكون من الصعب استغلالها لأي شيء أكثر من رفض الخدمة ، رغم ذلك. أيضًا ، قد تحتوي البرامج على حصص (أقل من حد النظام) لعدد الملفات التي يمكن فتحها ، لذلك لا يمكن لبرنامج واحد يعمل على نحو غير صحيح أن يفعل الكثير ، ويتم تحرير جميع ملفات العملية عند انتهاء العملية ، لذا من السهل عادةً يكفي لاستعادة الوظيفة (في الواقع ، ستتعطل معظم البرامج نفسها قبل فترة طويلة)

ومع ذلك ، إذا كنت تسمح للأشخاص بإخبار الخادم الخاص بك بفتح ملف ، فسيكون من الجيد أن يكون لديك حد لعدد الملفات التي يمكن فتحها في وقت واحد ، وإغلاق الملف (تلقائيًا ، إذا لم يوجه المستخدم ذلك أن يحدث أولاً) بعد وقت قصير قدر الإمكان.

هناك خطر آخر يتمثل في فتح اتصالات الشبكة ، اعتمادًا على نظام التشغيل الذي تعمل عليه وأنواع المسارات التي يقبلها. على سبيل المثال ، إذا قبل النظام مسارات نمط شبكة Windows ( server share path to file) أو SMB (بروتوكول شبكة Windows ، المنفذ على Unix-likes في مجموعة أدوات Samba) (smb: // server / مشاركة / مسار) ، أو طرق أخرى للوصول إلى أي نوع من أنظمة ملفات الشبكة التي لم يتم تحميلها بعد (أو "تم تعيينها" لاستخدام مصطلح Windows القديم) إلى نظام الملفات المحلي ، والتي قد تتسبب في قيام الخادم بفتح اتصال بالشبكة لصندوق المهاجم وربما تحاول المصادقة. قد يكشف هذا عن معلومات حول الخادم ، ويمكن أن يوفر موجهًا للمهاجمين لمحاولة اختراق الخادم عبر الاستجابات الضارة.

لذلك ، يجب عليك أيضًا تقييد أسماء الملفات على الأشياء التي يمكنك التأكد حقًا من أنها ليست مسارات بعيدة. بشكل عام ، ربما يجب أن تتجنب السماح بتحديد المسارات على الإطلاق ، واسمح فقط بأسماء الملفات. هذان هما الخطران الوحيدان اللذان يمكنني التفكير فيهما. خلاف ذلك ، فهو آمن جدًا.


يتسبب رمز VS في تجميد 17.10 و 18.04 بشكل عشوائي وكامل

يرجى القراءة: انظر الجزء الأخير. لا أعتقد أن هذه مشكلة متعلقة بـ Ubuntu ، ولكنها تتعلق بـ VS Code.

في الآونة الأخيرة ، تحت 17.10 و 18.04 (لقد قمت بالترقية اليوم) ، سيتم تجميد Ubuntu بشكل عشوائي وكامل. لا يمكنني تحريك المؤشر أو استخدام لوحة المفاتيح. بطبيعة الحال ، لقد حاولت التبديل إلى جلسة TTY ولكن دون جدوى. في كل مرة ، يجب أن ألجأ إلى SysRq + R E I S U B ، وهو (من الواضح) غير مفضل.

لقد حاولت تبديل برامج تشغيل الرسومات ، على أساس النظرية القائلة بأنه قد يكون كذلك. كنت في الأصل أستخدم برنامج تشغيل nVidia مفتوح المصدر ، وتحولت إلى الملكية دون جدوى. أنا أستخدم حاليًا برنامج تشغيل مفتوح المصدر.

كل ما أفتحه عادةً هو Firefox (ليس عددًا كبيرًا من علامات التبويب محمل) و VS Code ، مع فتح ملفين على الأكثر ومحطة طرفية.

تحديث: لا تعرض سجلات النظام أي إشارة إلى اى شى يحدث على الإطلاق ، ناهيك عن حدوث شيء خاطئ. لا أعرف ما إذا كان هذا مرتبطًا ، ولكن في بعض الأحيان (وخاصة بعد التمهيد) تستغرق البرامج وقتًا طويلاً (> 5-10 ثوانٍ) ، حتى برامج سطر الأوامر.

تحديث آخر! - حتى مع تعطيل جميع امتدادات جنوم ، لا يزال يتعطل. لقد جربت XFCE ، والتي لا تزال معطلة

ملخص: يتجمد Ubuntu تمامًا في أوقات تبدو عشوائية ، ولا يترك أي أثر في السجلات ، ولا يرتبط بأي بيئة سطح مكتب معينة أو امتدادات جنوم.

(من المحتمل أن يكون التحديث النهائي): أنا مقتنع بأن هذه مشكلة تتعلق بـ VS Code. لقد قمت بتشغيل GNOME منذ أيام ، مع فتح تطبيقات Electron الأخرى (Slack و Pulse وما إلى ذلك) ، ولم يكن لدي أي تجميد. لدي DM'd VS Code على Twitter ، ومن المحتمل أن أقدم تقريرًا بالخطأ لأنهم لم يستجيبوا بعد.


المتحدثون ردوا:

تايلر جاكستاتر

هل يتسبب أي شيء متعلق بـ Python في تعطل ArcGIS for Desktop؟ - نظم المعلومات الجغرافية

TSTL: لغة اختبار البرمجة النصية للنموذج

TSTL هي لغة خاصة بالمجال (DSL) ومجموعة من الأدوات لدعم الإنشاء الآلي لاختبارات البرامج. يستهدف هذا التطبيق لغة Python. أنت تحدد (في Python) مجموعة من المكونات المستخدمة لبناء اختبار ، وأي خصائص تريد الاحتفاظ بها للنظام الذي تم اختباره ، وتقوم TSTL بإنشاء اختبارات لنظامك. يدعم TSTL إعادة الاختبار ، وخفض الاختبار ، وتحليل تغطية الكود ، ويتضمن دعم الضغط على الزر لبعض أساليب إنشاء الاختبارات المعقدة. بمعنى آخر ، TSTL هو ملف الاختبار القائم على الملكية أداة.

ما هو الاختبار القائم على الملكية؟ الاختبار القائم على الخاصية هو الاختبار الذي لا يعتمد على المطورين الذين يحددون النتائج لمدخلات معينة أو تسلسل استدعاء ، ولكن على مواصفات عامة أكثر للسلوك ، جنبًا إلى جنب مع التوليد التلقائي للعديد من الاختبارات للتأكد من أن المواصفات العامة صحيحة. لمزيد من المعلومات حول الاختبار القائم على الملكية ، انظر:

https://github.com/trailofbits/deepstate (أداة تجمع بين التحليل الرمزي والتشويش بالاختبار القائم على الخصائص ، لـ C و C ++ ، مع تصميم مستنير إلى حد ما بواسطة TSTL)

يمكنك الحصول على أحدث tstl بسهولة باستخدام النقطة. يجب أن تعمل نقطة تثبيت tstl بشكل جيد. إذا كنت تريد شيئًا أحدث يمكنك القيام به:

لتغطية الكود ، ستحتاج أيضًا إلى تثبيت تغطية Ned Batchelder للتغطية. كل ما هو مطلوب.

للحصول على فكرة عن كيفية عمل TSTL ، دعنا نجرب مثالاً على لعبة. سنستخدم TSTL لحل "اللغز" البسيط لمعرفة ما إذا كان من الممكن إنشاء القيمة الصحيحة 510 باستخدام بضعة أسطر فقط من كود Python ، باستخدام مجموعة صغيرة فقط من العمليات (أضف 4 ، اطرح 3 ، اضرب في 3 ، وتنتج قوة اثنين) بدءًا من 0.

كما هو الحال في Python العادية ، يشير # إلى تعليق. توجد سطور التعليق أسفل رمز TSTL الذي يتم وصفه.

يجب أن يجد هذا ، في بضع ثوان ، طريقة لانتهاك الخاصية (إنتاج القيمة 510) ، والعثور على نسخة بسيطة للغاية من "اختبار الفشل" ، وإنتاج ملف nutshell.test يحتوي على الاختبار. إذا كنا قد حذفنا كانت TSTL إما قد وجدت طريقة لإنتاج 510 ، أو (أقل احتمالًا) كانت قد وجدت طريقة لإنتاج فائض في استدعاء الأسرى: سيعتبر أي منهما فاشلاً.

سيؤدي هذا إلى إعادة الاختبار الذي قمت بإنشائه للتو.

تتمثل الفكرة الأساسية لـ TSTL في تحديد مجموعة من الخطوات المحتملة في الاختبار ، بالإضافة إلى الخصائص التي تصف ما يمكن اعتباره فشلًا في الاختبار ، والسماح لـ TSTL بمعرفة ما إذا كانت هناك سلسلة من الإجراءات التي ستؤدي إلى فشل الاختبار. قد تكون الإجراءات عبارة عن استدعاءات وظيفية أو طريقة ، أو خطوات تجمع بيانات الإدخال (على سبيل المثال ، إنشاء سلسلة لتمريرها إلى المحلل اللغوي) ، أو ، حقًا ، أي شيء يمكنك فعله باستخدام Python.

تقوم TSTL بتثبيت بعض الأدوات القياسية: مترجم TSTL نفسه ، tstl مولد اختبار عشوائي tstl_rt أداة لإنتاج اختبارات قائمة بذاتها ، tstl_standalone أداة لإعادة تشغيل ملفات اختبار TSTL ، tstl_replay أداة لتصحيح أخطاء دلتا وتطبيع اختبارات TSTL ، tstl_reduce و a أداة لإجراء مجموعة من الاختبارات مثل الانحدار ، tstl_regress.

يمكنك القيام بمعظم ما تحتاجه فقط بالأوامر tstl و tstl_rt و tstl_replay و tstl_reduce.

  • يقوم tstl & ltfilename.tstl & gt بتجميع ملف .tstl في واجهة sut.py للاختبار
  • يقوم tstl_rt بتشغيل اختبار عشوائي على sut.py في الدليل الحالي ، ويقوم بإفراغ أي أخطاء تم اكتشافها في ملفات الاختبار.
  • tstl_replay & ltfilename.test & gt يدير اختبار TSTL محفوظًا ، ويخبرك إذا نجح أو فشل مع - overbose فإنه يوفر تتبعًا مفصلاً إلى حد ما لتنفيذ الاختبار
  • tstl_reduce & ltfilename.test & gt & ltnewfilename.tstl & gt يأخذ & ltfilename.test & gt عمليات التخفيض والتطبيع عليه لإنتاج اختبار أقصر وأسهل للفهم ويحفظ الإخراج كـ & ltnewfilename.tstl & gt.

تقدم كل هذه الأدوات عددًا كبيرًا من خيارات التكوين - ستنتج المساعدة قائمة بالخيارات المدعومة لجميع أدوات TSTL.

قد تكون أسهل طريقة لفهم TSTL هي فحص الأمثلة / AVL / avlnew.tstl (https://github.com/agroce/tstl/blob/master/examples/AVL/avlnew.tstl) ، وهو مثال بسيط لملف في أحدث تنسيق لغة.

ينشئ avlnew.tstl جهاز اختبار كامل الميزات لفئة شجرة AVL. يمكنك كتابة شيء سريع جدًا وفعال إلى حد ما ببضعة سطور من التعليمات البرمجية ، ومع ذلك:

يشير هذا إلى وجود نوعين من "الأشياء" المتضمنة في اختبار تنفيذ شجرة AVL: int و avl. نحدد ، في Python ، كيفية إنشاء هذه الأشياء ، وما يمكننا فعله بهذه الأشياء ، ثم ينتج TSTL تسلسلات من الإجراءات ، وهذا هو الاختبارات، التي تطابق تعريفنا. يتحقق TSTL أيضًا من أن جميع أشجار AVL ، في جميع الأوقات ، متوازنة بشكل صحيح. إذا أردنا ، كما هو الحال في avlnew.tstl ، يمكننا أيضًا التأكد من أن شجرة AVL الخاصة بنا "تعمل مثل" مجموعة --- عندما نقوم بإدخال شيء ما ، يمكننا العثور على هذا الشيء ، وعندما نحذف شيئًا ما ، لم يعد بإمكاننا العثور عليه هو - هي.

لاحظ أننا نبدأ بـ "raw Python" لاستيراد وحدة avl ، SUT. بينما يدعم TSTL استخدام from والأسماء المستعارة وأحرف البدل في عمليات الاستيراد ، يجب دائمًا استيراد الوحدة (الوحدات) قيد الاختبار باستيراد بسيط. يسمح هذا لـ TSTL بتحديد الكود المراد اختباره وتوفير التغطية تلقائيًا وطرق الاختبار بمساعدة التحليل الثابت والإدارة المناسبة للوحدة. من ناحية أخرى ، يمكن استيراد رمز الأداة المساعدة في المكتبة القياسية بالطريقة التي تريدها.

إذا اختبرنا هذا (أو avlnew.tstl) لمدة 30 ثانية ، فسيظهر شيء مثل هذا:

/ tstl / أمثلة / AVL $ tstl_rt - انتهت المهلة 30

بالنسبة للعديد من البرامج (ولكن ليس كلها!) ، فإن البديل الأكثر قوة للاختبار العشوائي البسيط هو استخدام اختبار السرب ، والذي يقيد الإجراءات في كل اختبار فردي (على سبيل المثال ، إدراج ولكن لا حذف ، أو العثور على عمليات اجتياز بالترتيب ولكن لا يوجد) (انظر http : //agroce.github.io/issta12.pdf).

هنا ، هذه الطريقة ليست مهمة جدًا ، فالاختبار العشوائي البسيط يقوم بعمل لائق يغطي كود شجرة AVL في 60 ثانية فقط. إذا قدمنا ​​خطأ عن طريق إزالة استدعاء self.rebalance () على السطر 205 من avl.py ، فإن أي من الطريقتين ستبلغ بسرعة عن حالة اختبار فاشلة ، ويتم تقليلها تلقائيًا. بشكل افتراضي ، سيجري المختبر العشوائي الاختبار في وضع مطول لإظهار المزيد من التفاصيل عما يحدث أثناء التنفيذ والذي يتسبب في حدوث فشل.

باستخدام --output ، يمكن حفظ الاختبار الفاشل في ملف مسمى ، وباستخدام الأداة المساعدة standalone.py ، يتم تحويلها إلى حالة اختبار قائمة بذاتها لا تتطلب TSTL نفسها. بدون - إخراج ، يظل الاختبار محفوظًا ، لكن الاسم يعتمد على معرف العملية الخاص بـ tstl_rt. في كلتا الحالتين ، يمكنك بسهولة إعادة تشغيل اختبار محفوظ ، حتى بدون التحويل إلى اختبار مستقل ، باستخدام tstl_replay & lttestname & gt ، وتقليله باستخدام tstl_reduce. تُعد علامة --verbose مفيدة لإعادة العرض ، حيث ستُظهر لك بالضبط ما يحدث أثناء الاختبار.

التلميح النهائي المفيد للبدء هو أنه في بعض الأحيان قد ترغب في اختبار شيء ما (على سبيل المثال ، مكتبة مطبقة في C) حيث تؤدي الاختبارات الفاشلة إلى تعطل مترجم Python. هذا ممكن ، لكنه يتطلب بعض الجهد. أولاً ، قم بتشغيل tstl_rt باستخدام الخيار --replayable. يؤدي هذا إلى احتفاظ المولد بملف ، currtest.test ، في الدليل الذي تقوم بتشغيل الاختبار فيه: هذا الملف يحمل الاختبار الحالي. إذا تعطل جهاز الاختبار العشوائي ، فسيشمل ذلك الإجراء الذي تسبب في التعطل. في بعض الحالات النادرة ، يكون سلوك الاختبارات السابقة وثيق الصلة أيضًا بالتعطل (إعادة تحميل الوحدة لا يؤدي بالفعل إلى إعادة تعيين حالة النظام - على سبيل المثال ، التفاعل مع الأجهزة). لهذه الحالات ، استخدم --total وانظر إلى الملف fulltest.test ، الذي يحتوي على جميع الإجراءات التي تم تنفيذها من قبل المختبِر العشوائي.

يعمل ملف currtest.test و fulltest.test تمامًا مثل ملفات TSTL العادية ، ويمكن إعادة تشغيلها باستخدام الأداة المساعدة لإعادة التشغيل أو تحويلها إلى ملفات مستقلة. ومع ذلك ، لكي يعمل الحد من الاختبار والتطبيع بشكل صحيح ، يجب تقليلهما بتمرير الوسيطة --sandbox إلى tstl_reduce.

ماذا عن الاختبارات التي تفشل بدخول حلقة لا نهائية؟ نفس الأسلوب المستخدم في أعمال الأعطال. ومع ذلك ، تحتاج إلى تشغيل tstl_rt بحد زمني (باستخدام ulimit إذا كنت تستخدم أنظمة تشبه UNIX ، على سبيل المثال). توفر الأداة المساعدة tstl_reduce وسيطة - timeout للتعامل مع مثل هذه الاختبارات ، ولكن هذا يعمل فقط على الأنظمة التي تدعم ulimit في الوقت الحالي. في حالات نادرة جدًا ، قد يكون لديك قفل تنفيذ اختباري لأن الفشل ، على سبيل المثال ، يتسبب في قراءة من الإدخال القياسي. إذا ضربت هذا ، اتصل بي.

أخيرًا ، كيف تدمج اختبار TSTL مع الأساليب الأكثر تقليدية ، على سبيل المثال ، pytest؟ يُظهر الملف test_tstl_regressions.py في دليل الأمثلة طريقة واحدة. إذا قمت بإضافة جميع اختبارات TSTL التي تهمك إلى دليل tstl_tests ضمن الدليل حيث يوجد sut.py ، فيمكنك جعل pytest يقوم بتشغيل جميع اختبارات TSTL الخاصة بك. ولعل الأمر الأكثر إثارة للاهتمام هو أن هذا الملف يلف أيضًا متصلًا بسيطًا يفرض 60 ثانية من الاختبار العشوائي ليتم تنفيذه بواسطة pytest ، كتحقق من الصحة. يمكنك تعديل تكوين الاختبار العشوائي بسهولة - في كثير من الأحيان ، تعد إضافة "- swarm" فكرة جيدة.

اختبار TSTL والطفرة

باستخدام أداة Universalmutator ، يمكنك بسهولة التحقق من قوة أدوات اختبار TSTL للعثور على الأخطاء. على سبيل المثال ، إذا أردنا معرفة مدى فعالية 10 ثوانٍ من الاختبار العشوائي باستخدام أداة AVL الخاصة بنا ، فيمكننا القيام بذلك:

يشير هذا إلى درجة المسوخ التي لا يغطيها اختبارنا ، والتي قد تكون ذات أهمية قليلة إذا كنا نستهدف جزءًا فقط من واجهة برمجة التطبيقات. وبصراحة ، هناك طرق أسهل لمعرفة الكود الذي لم يتم تغطيته من استخدام اختبار الطفرات! لذلك قد نرغب في قصر تحليلنا على الكود الذي تم تغطيته فعليًا بواسطة أداة AVL ، باستخدام مهلة كبيرة:

أحيانًا لا يكفي إجراء tstl_rt أو حتى tstl_rt --swarm. هناك خيارات أخرى لتحسين الاختبار. واحد قوي بشكل خاص في كثير من الحالات هو استخدام حجم الوظائف من حيث سطور التعليمات البرمجية لتوجيه الاختبار. للقيام بذلك ، عليك أولاً السماح لـ TSTL بتحديد الأحجام:

tstl_rt --generateLOC sut.loc - مهلة 120

ثم تستخدم هذا الملف الذي تم إنشاؤه لتوجيه الاختبار:

إنها أيضًا فكرة جيدة ، لإجراء اختبار أسرع (نظرًا لأن قوة الاختبار العشوائي تكمن جزئيًا في توليد أعداد هائلة من الاختبارات كل دقيقة) ، لإيقاف تشغيل جمع تغطية الكود باستخدام --noCover. هذا ليس رائعًا إذا كنت تتطلع لمعرفة ما إذا كانت اختباراتك تغطي الكود الخاص بك جيدًا ، ولكن بالنسبة لصيد الأخطاء من الدواسة إلى المعدن ، غالبًا ما يكون هذا هو السبيل للذهاب.

هناك أشياء أخرى يمكنها تحسين الاختبار. يجمع الخيار --profileProbs معلومات حول عدد المرات التي تم فيها اتخاذ كل إجراء في أداة تسخير TSTL أثناء الاختبار ، ويحيز خطيًا اختيار الإجراء العشوائي تجاه الإجراءات التي تم اتخاذها مرات أقل. يؤدي هذا إلى إبطاء إنشاء الاختبار بشكل كبير في معظم الحالات ، ولكن بالنسبة للعديد من البرامج (خاصة البرامج المعقدة) ، فإنه يعمل أيضًا على تحسين تغطية التعليمات البرمجية واكتشاف الأخطاء بشكل كبير ، من خلال استكشاف الإجراءات التي يصعب الوصول إليها ، وقضاء وقت أقل في إنشاء بيانات الإدخال مقابل تشغيل SUT . في هذه الحالات ، يتم تعويض الخسارة في إنتاجية الاختبار الناتجة عن محاولات اتخاذ إجراءات محتملة التعطل أكثر بكثير من خلال تحسين جودة الاختبار. نظرًا لأن كلاهما يعتمد على تعيين احتمالات الإجراء ، فإن --profileProbs و - biasLOC غير متوافقين للأسف.

بالنسبة لبعض البرامج ، تعمل بنية ملف التسخير على إبطاء إنشاء الاختبار ، ويمكن أن يحسن الخيار --useDependencies إنتاجية الاختبار بمعامل 2-10x. ومع ذلك ، بالنسبة لمعظم البرامج ، فإن هذا الخيار يبطئ إنشاء الاختبار بمقدار ضعفين تقريبًا.

نظرًا لاختلاف فائدة هذه الخيارات على نطاق واسع ، فمن الأفضل تجربتها ببساطة. بالنسبة إلى --profileProbs ، يجب أن ترى زيادة كبيرة في تغطية الكود إذا كانت فعالة لمشكلة الاختبار (ربما تكون مصحوبة بانخفاض كبير في عدد الاختبارات التي تم إنشاؤها) ، وبالنسبة إلى --useDependencies ، يجب أن ترى زيادة كبيرة في العدد من الاختبارات / عمليات الاختبار المنفذة.

يمكنك أيضًا تجربة نهج "الخوارزميات الجينية" الذي يسترشد بالتغطية ، والذي يستغل اختبارات "التغطية العالية":

tstl_rt -exploit 0.8 -Pmutate 0.5

تؤدي إضافة - reducePool أحيانًا إلى تحسين أداء هذه الطريقة.

يمكنك ضبط الاستغلال وتغيير المعلمات لمعرفة ما إذا كانت تؤدي إلى تحسين النتائج. يمكنك حتى الجمع بين تحيز سطور التعليمات البرمجية أو الاحتمالات المستندة إلى الملف الشخصي مع نهج الاستغلال و / أو اختبار السرب. لسوء الحظ ، فإن استخدام --exploit يعني أنه لا يمكنك الابتعاد عن --noCover لتجنب عبء تغطية كود الحوسبة.

نحن نعمل على طريقة لجعل TSTL تجري التجارب تلقائيًا وننصحك بأفضل تكوين لاختبار أداة تسخير معينة.

للحصول على مجموعة من "اختبارات الانحدار" السريعة جدًا ، يمكنك تشغيل tstl_rt لفترة طويلة بتكوين جيد باستخدام الخيار --quickTests ، وإنشاء مجموعة من الاختبارات القصيرة جدًا مع تغطية رمز عالية.

يدعم TSTL توطين الخطأ الآلي. إذا كان لديك أداة تعثر على خطأ ، فقد تحصل على نظرة ثاقبة لطبيعة هذا الخطأ من خلال تشغيل شيء مثل:

سيؤدي هذا إلى تشغيل TSTL لمدة ساعة ، وإنشاء عدد من حالات الاختبار الفاشلة (إذا كان من الممكن العثور على الخطأ الخاص بك بسهولة نسبيًا في غضون ساعة) ، ثم إعداد تقرير عن 20 عبارة وفروع خاطئة على الأرجح في الكود قيد الاختبار. قد يتم تضمين بعض هذه التعليمات البرمجية في أشياء مثل طباعة قيم التأكيد ، أو معالجة الخطأ للخطأ ، ولكن هناك فرصة جيدة لأن تجد رمز عربات التي تجرها الدواب في نتائج الترجمة ، في تجربتنا. في الواقع ، سيكون الجري لمدة خمس دقائق كافيًا للتوطين الجيد ، غالبًا ، إذا كانت خمس دقائق كافية للعثور على الخطأ الخاص بك عدة مرات. لاحظ أن النتائج تكون أسوأ بكثير إذا كان لديك أكثر من خطأ واحد!

طريقة واحدة لاستخدام اختبار السرب بشكل فعال هو التطبيق اختبار السرب الموجه، وهو نهج يتم فيه استخدام البيانات المتعلقة بكيفية تفاعل السرب مع تغطية الكود لتعزيز تغطية البيانات والفروع التي نادرًا ما يتم تغطيتها.

للقيام بذلك ، قم بتشغيل اختبارك الأولي باستخدام tstl_rt (لمدة ساعة أو أكثر) مع الخيارات:

سيؤدي ذلك إلى اختبار برنامجك وإنتاج ملفين مهمين. & ltfilename2 & gt يحتوي على ملف نصي بسيط مع الفروع والبيانات المشمولة ، مرتبة حسب عدد المرات التي تمت تغطيتها فيها. هذه في الأساس نسخة مبسطة من نوع المخرجات التي قد تكون على دراية بها من gcov أو أدوات أخرى. يمكنك إلقاء نظرة على هذا الملف ، وتحديد كود مثير للاهتمام ، ولكن نادرًا ما يتم تغطيته.

بعد ذلك ، خذ المعرف (السلسلة الكاملة ، بما في ذلك الأقواس) من الكود المثير للاهتمام واستخدم أداة tstl_directedswarm مثل هذا:

tstl_directedswarm & ltfilename1 & gt "& ltcoverage target & gt" & ltprobFile & gt

(& ltfilename1 & gt هو الملف الذي أنتجته في التشغيل الأصلي لاختبار السرب.) سيحاول هذا اكتشاف الإجراءات التي تساعد ("المشغل") وتعوق ("منع") تغطية الكود الهدف ، وإنتاج ملف (ملف محتمل) مع احتمالات للاستخدام في اختبار سرب أكثر تركيزًا. إذا لم تحدد الأداة أي محفزات أو مثبطات ، فحاول تشغيلها مرة أخرى باستخدام الخيار - Confidence وعدد أقل من 0.95 ، وكلما انخفضت الثقة المطلوبة ، زادت احتمالية العثور على المشغلات والمثبطات ، ولكن قل احتمال حدوثها لتكون ذا مغزى - يمكنك محاولة الخفض ببطء حتى تحصل على بعض النتائج. ثم قم بإجراء الاختبار مرة أخرى ، على النحو التالي:

tstl_rt --swarm --swarmProbs & ltprob ملف & GT

يجب أن تكون قادرًا عادةً على تغطية الكود الذي نادرًا ما يتم تغطيته بهذه الطريقة. نظرًا لأن التغطية نادرًا ما تكشف عن رمز جديد مثير للاهتمام لم يسبق له مثيل ، فقد ترغب في تكرار هذه العملية بمجرد استكشاف الشفرة التي نادرًا ما يتم تغطيتها من التشغيل الأولي. يمكنك بالطبع تخزين تغطية السرب وإحصائيات التغطية الكاملة للتشغيلات المركزة لـ TSTL ومواصلة الاستكشاف.

هناك طريقة أكثر منهجية لإجراء اختبار السرب الموجه وهي تجربة:

tstl_analyzeswarm & ltfilename1 & gt & ltprefix & gt - cutoff 0.5

لإنشاء مشغلات ومثبطات لجميع أهداف التغطية التي تم ضربها أثناء التشغيل ، مجمعة في فئات التكافؤ (الأهداف مع نفس مجموعة المشغلات والمثبطات) وتصنيفها حسب الهدف الأقل إصابة في كل فئة معادلة. سيتم تخزين الإخراج في ملفات تبدأ بـ & ltprefix & gt: مجموعة من الملفات المسماة & ltprefix & gt.N.probs التي يمكن استخدامها مع --swarmProbs وملف فئة واحد ، مع جميع الأهداف والمشغلات والمثبطات والحد الأدنى للترددات للفئات ، بالإضافة إلى مؤشرات لملفات الاحتمالات ذات الصلة. يعد مجرد تكرار ملفات الاحتمالات التي تم إنشاؤها لفئات الأهداف النادرة طريقة جيدة لإجراء اختبار السرب الموجه. 0.5 أعلاه يمكن أن يكون أي قطع ، فوق ذلك فإن الأهداف التي يتم ضربها على الأقل بهذا الجزء من الاختبارات تعتبر مجربة جيدًا ويتم تجاهلها. يمكن أن يعمل تعيين هذا على مستوى منخفض يصل إلى 0.01 بشكل جيد ، بالنسبة للتشغيل الأولي الذي ينتج عددًا كبيرًا من الاختبارات.

TSTL و American Fuzzy Lop (AFL) Fuzzer

يمكنك حتى استخدام AFL (http://lcamtuf.coredump.cx/afl/) لإنشاء اختبارات TSTL. تحتاج إلى تثبيت AFL نفسه وحزمة python-afl pip (أو الحصول على الكود من github على https://github.com/jwilk/python-afl). ثم يمكنك استخدام AFL في أي دليل باستخدام أداة TSTL المترجمة:

tstl_afl_fuzz - Output & ltoutputdir & gt --input & ltinputdir & gt

سيستخدم هذا بعض الإعدادات الافتراضية (عادةً ما تكون جيدة) لجعل TSTL تقوم أولاً بإنشاء بعض اختبارات البداية الجيدة لـ AFL للبناء عليها ، ثم تشغيل AFL ليوم واحد على SUT. قد لا يكون اليوم كافيًا ، لذلك يتم دعم نفس معلمة timeout كما هو الحال في اختبار TSTL العشوائي. يمكنك أيضًا استخدام اختبار السرب بإضافة --swarm. هناك أيضًا خيارات أخرى أقل استخدامًا. سيتم تخزين الاختبارات الفاشلة التي تم إنشاؤها بواسطة AFL على أنها aflfail. & ltPID & gt.test في الدليل الحالي. نصيحة واحدة: من المحتمل أن تكون & ltoutputdir & gt عبارة عن قرص مضغوط ، إلا إذا كنت تريد حقًا مطرقة SSD (لا تفكر حتى في القيام بذلك على محرك أقراص ثابت فعلي).

يجب عليك أيضًا تجربة الخيار - persist إلى tstl_afl_fuzz ، والذي سيؤدي غالبًا إلى تحسين سرعة التشويش بهامش كبير ، وتحسين نتائج AFL بشكل كبير (نظرًا لأن الإنتاجية بالغة الأهمية) ، ومع ذلك ، فإن هذا أقل اختبارًا جيدًا إلى حد ما من الوضع غير المستمر . مع المزيد من الاختبارات ، من المحتمل أن يصبح هذا هو الإعداد الافتراضي ، لذلك قد ترغب في القفز إلى المقدمة ، وتشغيل الوضع غير الدائم فقط إذا بدا أن الوضع المستمر يسبب مشاكل.

يعد هذا خيارًا قويًا للاختبار ، حيث يتيح لك استخدام أساليب الاستدلال الرائعة في AFL لإبهام الأشياء التي تكون في أحسن الأحوال غير مريحة للغاية مع AFL فقط. يمكنك إعداد خصائص TSTL المعقدة ، ومزج توليد القواعد وتسلسلات استدعاء API ، والقيام باختبار تفاضلي على غرار TSTL ، ولكن استخدام أساليب إنشاء المدخلات المضبوطة الخاصة بـ AFL. العيب الرئيسي هو أن AFL تتوقع حقًا ملفات تنفيذية أسرع بكثير مما تقدمه TSTL ، لذلك ربما تحتاج إلى الجري لأيام لتحسين ما يمكن لـ TSTL القيام به في غضون ساعة ، ما لم يكن SUT الخاص بك غير عادي. لكنه بالتأكيد خيار جذاب للاختبار الشاق لمدة أسبوع عندما لا تجد tstl_rt أي مشاكل.

لاحظ أنه إذا كنت لا تستخدم tstl_afl_fuzz ولكنك اتصلت بشكل مباشر بـ py-afl-fuzz ، فربما تحتاج (باستثناء نظام التشغيل Mac OS ، حيث لا يعمل الحد من الذاكرة على أي حال) إلى حجم كبير حتى يعمل TSTL.

تحت غطاء محرك السيارة ، يأخذ الأمر tstl_afl ملفًا من البايتات ويفسر كل N بايت (يعتمد N على عدد الإجراءات التي يمتلكها تسخيرك) كمؤشر لإجراء TSTL (مقياس عدد الإجراءات) ، باستخدام sut.py كالمعتاد. عندما يكتشف tstl_afl فشلًا ، فإنه ينتج أيضًا ملف اختبار TSTL تقليدي تحت الاسم aflfail. & ltPID & gt.test. يمكنك حتى استخدام --swarm لتفسير أول 4 بايتات على أنها بذرة للتحكم في اختبار السرب ، وبالتالي السماح لـ AFL باستخدام اختبار السرب ، وهذا له عيب يتمثل في أن الملف سيتم تفسيره بشكل غير صحيح بواسطة أدوات TSTL الأخرى ، ما لم تمررها - خيار -aflswarm. تأخذ معظم أدوات TSTL خيار --afl الذي يشير إلى أن الاختبارات المراد قراءتها بتنسيق AFL و --aflswarm للإشارة إلى أنها اختبارات سرب.

يفيد tstl_afl أيضًا في تحويل ملف بايت واحد AFL إلى ملف اختبار TSTL عادي ، باستخدام الخيار --alwaysSave ، الذي يفرغ ملف اختبار TSTL في الدليل الحالي ، الذي تم إنشاؤه من الإدخال المستند إلى البايت.

هناك أيضًا أدوات لتحويل أعداد كبيرة من الملفات من وإلى تنسيق AFL. يأخذ tstl_toafl ملفات اختبار TSTL الموجودة ويحولها إلى مدخلات بايت AFL ، ويقوم tstl_fromafl بالعكس المتوقع (ويأخذ حجة تشير إلى أن الملفات في تنسيق سرب). يولد tstl_aflcorpus بشكل عشوائي مدخلات تؤدي إلى تغطية SUT جديدة لبدء AFL ، ولكن عادةً ما يكون من الأسهل إنشاء اختبارات سريعة باستخدام tstl_rt --quickTests وتحويل تلك باستخدام tstl_toafl. يسمح tstl_aflcorpus باستخدام تنسيق سرب AFL ، ولكن فقط قم بتشغيله باستخدام --swarm. نظرًا للطريقة التي يعمل بها تنسيق السرب ، فمن غير الممكن حاليًا للأسف استخراج اختبار تنسيق سرب من اختبار TSTL القياسي.

tstl_smallcheck هو مولد اختبار ذو أغراض خاصة يستخدم بحث العمق أولاً لإنشاء اختبارات شاملة تصل إلى حد العمق المحدد. تقوم الأداة بإخراج اختبارات زيادة التغطية ، وتتوقف إذا واجهت فشلًا. نادرًا ما ينتهي هذا إذا كان العمق أكثر من 3 إلى 10 (على الأكثر) خطوات ، إلا إذا حدث فشل. إذا نفد صبرك ، يمكنك مقاطعة العملية باستخدام CTRL-C وستحفظ الأداة الاختبارات المكتشفة.

تتمثل إحدى طرق الحصول على اختبار "شامل" أعمق في استخدام الخيار - المتسلسل للاستكشاف من اختبارات زيادة التغطية ، مرارًا وتكرارًا لعدد محدود من المرات ، باستخدام نفس عمق التشغيل الأصلي (وعمق أولي صغير).

إذا كنت ترغب في جمع كل الاختبارات الفاشلة ، وليس التوقف عند الاختبار الأول فحسب ، فستحتاج إلى استخدام الخيار - متعدد. نظرًا لصغر حجمها والرغبة المفترضة في الاستكشاف الشامل (لقد استخدمت هذه الأداة ، بعد كل شيء) ، لا توفر هذه الأداة تقليلًا أو تطبيعًا لاختبارات التغطية أو الفشل ، لتجنب أي خطر الانزلاق.

بالإضافة إلى - متسلسل ، يمكنك استخدام - تمت الزيارة أو - قائمة الزيارة لتجنب إعادة زيارة الحالات التي تم استكشافها بالفعل أثناء DFS ، ومع ذلك ، فإن هذا يتطلب بعض العناية. إذا فشلت الأداة ، أو كانت الاختبارات لا تبدو صحيحة / صحيحة ، فقد ترغب في إعادة تجميع أداة التسخير باستخدام --defaultReplay ، لأن التراجع المستند إلى الحالة لا يعمل. في كثير من الحالات ، نظرًا لارتفاع تكلفة مقارنة الحالة في هذا الإعداد ، قد لا يكون تتبع الدول التي تمت زيارتها مفيدًا للغاية.

من المحتمل أن يكون الاختبار العشوائي باستخدام tstl_rt أكثر فعالية دائمًا من هذا النهج ، ولكن يمكن أن يوفر tstl_smallcheck ضمانات أن tstl_rt لا يمكن أن يتسبب ، مثل عدم وجود اختبار بأقل من أربع خطوات يمكن أن يسبب أي فشل. يعد بدء فحص صغير من الاختبارات السريعة الحالية باستخدام الخيار --fromTests إحدى الطرق لإضافة المزيد من الثقة في الاختبار.

قد يسأل بعضكم: "كيف تختلف TSTL عن الفرضية https://hypothesis.readthedocs.io/en/latest/ test tool؟" هناك بعض الإجابات. أولاً ، ربما تكون TSTL أقل تلميعًا من Hypothesis في الوقت الحالي! الأهم من ذلك ، أن كلا من Hypothesis و TSTL يولدان اختبارات ، لكن الغرض منهما في المقام الأول هو إنشاء أنواع مختلفة من الاختبارات. الفرضية هي ما نعتبره عائلة QuickCheck: إذا كان لديك دالة f تأخذ كمدخلات قائمة أو سلسلة أو شيء أكثر تعقيدًا ، فمن المحتمل جدًا أن تكون الفرضية هي ما تريد استخدامه. إذا كانت لديك مجموعة من الدوال ، f ، و g ، و h ، ولم تكتفِ بإرجاع الأشياء ، بل قامت بتعديل حالة النظام غير المرئية (ولكن أيضًا تعيد الأشياء التي قد تكون مدخلات إلى وظائف أخرى) ، فقد تحتاج إلى TSTL. يمكنك إجراء اختبار استدعاءات تسلسل الأسلوب على أساس الحالة باستخدام Hypothesis ، ولكن قد يكون الأمر أسهل مع TSTL ، وهو ما تم تصميم TSTL من أجله. لذا ، إذا كنت تختبر تنفيذ الفرز ، فمن المؤكد تقريبًا أن الفرضية أفضل بكثير. إذا كنت تختبر شيئًا مثل نظام الملفات ، فقد ترغب في النظر في TSTL. إذا كنت تختبر محللًا يأخذ سلسلة كمدخلات ، فقد تكون كلتا الأداتين مفيدتين ، اعتمادًا على الموقف لديك. أحد الاختلافات الإضافية للمستخدم العادي هو أن TSTL لديها دعم مدمج كبير لإجراء اختبار تفاضلي / مرجعي ، حيث تتم مقارنة SUT الخاص بك بتطبيق مرجعي ، ربما مع بعض التعليمات البرمجية للتعامل مع الاختلافات المتوقعة (انظر مثال pyfakefs للحصول على مظهر جيد في مدى قوة هذا). أخيرًا ، تم تصميم TSTL كأداة اختبار عملية ، لكن التصميم يتأثر بشدة بقرار جعله مفيدًا كمنصة لتجربة خوارزميات اختبار البرامج الجديدة.

التشابه هو أن كلا من TSTL و Hypothesis لا يبدوان مثل اختبار الوحدة التقليدي. They instead let you define the idea of a valid input (either some data values, or in TSTL a sequence of method calls and assignments that more resembles a traditional do-some-stuff-and-then-check-it unit test) and assert general properties about the behavior of a system under valid input.

Tips for Handling Numerous Bugs

If you test real software with a good harness, you may well find many issues. There are a few ways to deal with this. First, using --normalize when doing --multiple runs with tstl_rt can help. In some cases (file systems) normalization (or even reduction) goes too far. In testing at NASA, we found that "last operation" was a good heuristic for different bugs. Using --keepLast in testing (or when using tstl_reduce ) forces reduction and normalization to leave the last step alone. Normalization can still move it around, or change the pool it uses, but is much more careful about changing the actual action performed. There is also a tool tstl_triage that takes a glob expression for a set of tests, runs them all, and reports ones with different (heuristic) failure signatures. In particular, it gives you the shortest test for each signature. Remember that triage requires a glob expression (in quotes) not a list of files. This is so it can handle even sets of tests that go beyond the shell expansion limit. We assume that you won't need to handle that many tests in regression, but for triage, who knows? Another tool, tstl_fpf takes similar arguments to tstl_triage but instead of clustering tests into groups that are likely the same bug, it ranks all tests, such that very different tests are high in the ranking, using the "furthest-point-first" (FPF) method proposed by Chen et. al in PLDI 2013.

For more details on TSTL, the best starting point is a comprehensive journal paper in STTT: http://agroce.github.io/sttt17.pdf. There are also NASA Formal Methods (NFM) and International Symposium on Software Testing and Analysis (ISSTA) 2015 papers at http://agroce.github.io/nfm15.pdf and http://agroce.github.io/issta15.pdf, with some implementation details or concepts that are not present in the more up-to-date and complete paper. In particular, the NFM paper, "A Little* Language for Testing" has a deprecated syntax and other issues, but is the most concise explanation of the core TSTL idea: a DSL embedding a full programming language, designed to make testing (and building testing tools) easy.

There is a more recent paper describing test normalization, a feature unique to TSTL, in more detail, http://agroce.github.io/issta17.pdf, as well as a tool paper describing how to use TSTL's test manipulation commands (http://agroce.github.io/issta17tool.pdf).

The NFM and ISSTA papers use an early version of TSTL syntax, which marks pools and TSTL constructs with % signs. "Modern" TSTL uses <> by default, though if for some reason you need <> in your code (and to prepare for a future C++ version) this can be turned off and only % supported.

Note that documentation above is preliminary. The best way to get started, once you understand the basic tools ( tstl , tstl_rt , tstl_replay , and tstl_reduce ) is to examine the examples directory and try out real TSTL test harnesses. For the brave, reading tstl/randomtester.py provides considerable guidance in how to (efficiently) use TSTL in a generic testing tool, with TSTL providing an interface to the underlying application/library to be tested.

Note that TSTL was originally written for Python 2.7, has mostly been developed/tested that way, and is not extremely well-tested yet with Python 3.0+. However, it should work ok, thanks to mrbean-bremen, and the Travis tests check that TSTL works fine on Python 3.6. Earlier 3.0+ versions may have some "gotchas."

There are no developer docs yet, which will hopefully change in the future. The best shakedown test for tstl is to compile and run (using tstl_rt ) the AVL example. Removing any call to the balancing function in the avl.py code should cause TSTL to produce a failing test case.

Who is responsible for TSTL?

Alex Groce (agroce) wrote this file, and most of the current code base, and is running the show. If there is a problem with TSTL, it is my fault, and don't blame anyone below.

Josie Holmes (josieholmes) contributed to core language design changes, and is responsible for the ideas (and some of the code) for the various slippage reduction strategies, plus the LOC bias work and Markov things. Before Josie's work, TSTL was extremely hard to read, and considerably less efficient.

Jervis Pinto was the other original TSTL-er, and has his fingerprints on various parts of the early design and code that form the foundations of TSTL.

Pranjal Mittal contributed a number of critical elements, including the initial effort to prepare TSTL for a pip release as a useful tool, and has helped publicize TSTL.

Pooria Azimi added the <int,1> notation, which turns out to be one of the most important changes, and eliminated the need for the exceedingly awkward way of handling binding via Python functions and commit point based guards. Without this, you really don't have a useful TSTL.

Kevin Kellar developed a (beta) Java version of TSTL: https://github.com/flipturnapps/TSTL-Java.

My (Alex's) other graduate students (Amin Alipour, Rahul Gopinath, Arpit Christi, Chaoqiang Zhang, Shalini Shamasunder) and almost-mine graduate student (Iftekhar Ahmed) contributed to the general intellectual climate in which TSTL was born.

Students in CS 499 at Northern Arizona University and CS 362, 562, and 569 at Oregon State University contributed a lot of ideas, and a few concrete language/tool changes or bug reports. These are too numerous to mention, and in some cases I don't recall who asked "why do you do it that stupid way?" in class, and got me thinking that it was in fact a stupid way to do things.

Ned Batchelder, David R. MacIver, and John Regehr have no actual code in TSTL, but all contributed in significant ways to various implementation aspects, in ways that go beyond the general disclaimer that TSTL freely steals from the entire software testing (research) community.

The pyfakefs team (mrbean-bremen and jmcgeheeiv on github) really worked with me to test pyfakefs, which resulted in a number of nice improvements to TSTL and to differential testing in particular. More recently, mrbean-bremen has taken the lead in making TSTL compatible with Python 3, which seems to mostly be done now!

Jakub Wilk helped with modifications to python-afl that made TSTL/AFL integration work much better.

Corey Kosak helped turn this README into something that you might actually enjoy reading, and gets to the point much faster than previous versions.

* Do you actually remember that asterisk way up there? The footnote is that TSTL يكون a little language. However, in another sense, it embeds all of Python which makes it pretty big. It depends on how you think about it.


My Pi keeps crashing — where should I look?

I know my problem is too vague to solve the root problem. Please help me on my way.

My problem
I have a Pi setup with owncloud. And a external hard drive with videos on it.
It just functions as a NAS. I use SFTP for all my connections.
But it (seemingly) crashes at random. It crashed last night when it was idling, and does so a few times a week. Pulling the plug and reinserting it creates a successful reboot.

  • It's a Pi 2 Model B.
  • I tried 2 different power supplies for the Pi. Neither had problems with an older Pi model.
  • The external drive is externally powered.
  • I run the Pi headless.
  • When it crashes I can't login or reach it in any way. The power LED is lit.

My question:

  • Where should I look to narrow this down?
  • What might I do the log this behaviour?
  • Where is a place to get more specific support for this kind of broad, vague problems?

What helped so far

A comment made by Goldilocks to determine the difference if it really crashes or I just can log in.


As stuff is stored into, left, and eventually pulled out of RAM, some corruption naturally occurs (theories vary, but the one with the most weight right now is EMI from the computer itself). ECC is a feature of RAM and motherboards that allows detection and correction of this corruption.

The corruption is usually pretty minor (ECC can usually detect and fix 1-2 bits per 64 bit "word" - and that's waaaaay beyond the typical error rates), but increases in frequency with the density of the RAM. Your average workstation/PC will never notice it. On a server where you're running high density RAM 24/7 in a high-demand environment serving critical services, you take every step you possibly can to prevent stuff from breaking.

Also note that ECC RAM must be supported by your motherboard, and the average workstation/PC does not support it.

ECC RAM is more expensive than non-ECC, is much more sensitive to clock speeds, and can incur a small (1-2%) performance hit. If it helps, an analogy that works is RAM to RAID controllers. On your PC, that hardware-assisted software RAID built into your chipset is great protection against single disk failures. On a server, that would never be enough. You need high-end, battery-backed fully hardware RAID with onboard RAM to ensure that you don't lose data due to a power outage, disk failure, or whatever.

So no, you don't really need ECC RAM in your workstation. The benefit simply will not justify the price.

10% you'd expect from the additional chip area, for the same usable amount of RAM). It might be worth revisiting particularly the last sentence in light of this. &ndash user Oct 18 '15 at 13:07

If this article is anything to go by, then you should use ECC RAM.

It's not just a matter of "I don't run a server, so I don't need it". It depends how much you value your data. It's not just a matter of occasional crashes - the problem is you could get corruption and have no way of knowing that it's going on.

ECC RAM gets more interesting as memory sizes grow. The probability of a single bit error in a machine with 8GB of RAM is quite a lot higher than it was in the days of a 640K PC/XT, simply due to the larger number of bits. On a database server where that RAM might be in a disk buffer, a bit error can corrupt disk storage as well. Generally you would expect to use ECC memory on a server.

Some workstations (particularly those with Xeon or Opteron CPUs) take registered memory, which pretty much only comes in ECC flavours anyway. On a desktop PC you may view it as overkill.

ECC RAM is designed to aid in preventing and fixing memory based errors, usually using some sort of hamming code or modular redundancy. This is very useful in servers that contained important data, or need high availability, but it comes at a cost.

Whilst its probably worth paying the extra for your important servers, do you really want to do so for your desktop machine, does it matter if there is the occasionally memory error? Sure it matters if your SQL database drops some data during a transaction, but do you care if your word document is affected by a slight memory blip?

If you want a reliable workstation then you want ECC RAM for it. It will crash less often and work done on it and documents cached in RAM will not be randomly corrupted.

An additional benefit of ECC over what was mentioned above is that you can detect bad RAM. While running a long memtest86 session will usually find any problems, there may be very specific problems with the RAM which only show up rarely and in certain use cases. This can still happen much more frequently than the corruption that perfectly good ECC RAM is designed to protect against -- maybe once every month. So if you install monitoring software, you can be sure that your RAM is good, or replace bad chips. Still a marginal benefit, but as ECC memory is not much more expensive than normal RAM, it may be worth it.

ECC memory now costs about the same as non-ECC memory, as prices have dropped. So check prices if prices are anywhere close, buy ECC if your workstation accommodates it.

I think there may be some confusion just based on the title of the question.

If you just mean the average desktop PC, then that is usually based on a platform that doesn't even have ECC support.

If you mean a workstation class computer, then it quite likely comes with ECC memory whether you care about it or not.
Overall, the workstation class is typically based on essentially server hardware but with proper graphics and packaged in a different form-factor.

The expected workload is also more taxing than that of the desktop PC, so if you acknowledge that ECC makes sense for servers, then I think it's not much of a stretch that ECC also makes sense for workstations.

For Desktop PCs, there's some debate whether ECC would make sense or not. It can absolutely be argued that everything ought to have ECC but, right now, it's not practical as the industry has decided to make ECC a feature to differentiate higher end hardware.

According to the article Zan Lynx linked in the comments: DRAM Errors in the Wild: A Large-Scale Field Study, the uncorrectable errors are common while random correctable errors appear rarely in a system. The incidence is probably a few in a year, but it depends on the usage.

So in a server environment the correctable errors might not be that important, but you boot the server machines rarely, so uncorrectable errors caused by failing RAM can be there undetected for a while corrupting your data. I think that's the main reason why servers need ECC. Workstations boot and so check RAM frequently, so hardware failures can be detected by every reboot. If that frequency is sufficient for your business, then I think you won't need ECC RAM in your workstation.

If we are talking about memory errors, it is better to version the important documents on the server. So if the workstation reads and modifies something, then the original content should not be overwritten on the server. Regular backups can do the same for you.

Another aspect of this question is security. If your workstation is connected to any non-safe network, then it might be vulnerable to the row hammer attack, which exploits a DRAM related phenomenon. So from security perspective it is better to use ECC RAM.

I would use ECC everywhere, always, and I'm upset and disappointed I cannot get it on my MacBook Pro laptop, because otherwise it could completely replace my desktop server. In my desktop server, over 10 years I have had to replace 2 memory sticks due to persistent errors which would have just been random crashes and data corruption if it were not for ECC detecting and correcting them. Not counting all the errors in those failed sticks, I would estimate seeing about 8 errors per year. Of course, this is a tiny sample and anecdotal evidence a much better resource is Google's study which showed that about 1/3 of their servers experienced at least one memory error in a given year.

I agree with Linus Torvalds (creator of Linux) that the real driving force behind keeping ECC unavailable is Intel:

Torvalds takes the bold position that the lack of ECC RAM in consumer technology is Intel's fault due to the company's policy of artificial market segmentation. Intel has a vested interest in pushing deeper-pocketed businesses toward its more expensive—and profitable—server-grade CPUs rather than letting those entities effectively use the necessarily lower-margin consumer parts.

Removing support for ECC RAM from CPUs that aren't targeted directly at the server world is one of the ways Intel has kept those markets strongly segmented. Torvalds' argument here is that Intel's refusal to support ECC RAM in its consumer-targeted parts—along with its de facto near-monopoly in that space—is the real reason that ECC is nearly unavailable outside the server space.


StackTracker - Cross-platform desktop notification app

The application displays a task tray notification when someone has posted an answer or a comment to a question you are tracking on any of the StackExchange sites. Clicking the notification will open the corresponding question in your browser.

License

GPL - Full LICENSE file available in the repo (below)

Download

Linux build: Download Linux ZIP (Requires Python 2.6 and PyQt4 to be installed)

Run >> python StackTracker.py from the StackTracker folder

Windows build: Download Windows ZIP (May need Microsoft VC++ DLL installed)

Launch the StackTracker.exe .

Mac OS X build: Download Mac OS X tarball (Requires Growl to be installed)

Launch StackTracker.app . Only tested in Leopard/Snow Leopard on Intel-based Macs.


kill -9 (SIGKILL) always works, provided you have the permission to kill the process. Basically either the process must be started by you and not be setuid or setgid, or you must be root. There is one exception: even root cannot send a fatal signal to PID 1 (the init process).

However kill -9 is not guaranteed to work immediately. All signals, including SIGKILL, are delivered asynchronously: the kernel may take its time to deliver them. Usually, delivering a signal takes at most a few microseconds, just the time it takes for the target to get a time slice. However, if the target has blocked the signal, the signal will be queued until the target unblocks it.

Normally, processes cannot block SIGKILL. But kernel code can, and processes execute kernel code when they call system calls. Kernel code blocks all signals when interrupting the system call would result in a badly formed data structure somewhere in the kernel, or more generally in some kernel invariant being violated. So if (due to a bug or misdesign) a system call blocks indefinitely, there may effectively be no way to kill the process. (But the process will be killed if it ever completes the system call.)

A process blocked in a system call is in uninterruptible sleep. The ps or top command will (on most unices) show it in state D (originally for “دisk”, I think).

A classical case of long uninterruptible sleep is processes accessing files over NFS when the server is not responding modern implementations tend not to impose uninterruptible sleep (e.g. under Linux, the intr mount option allows a signal to interrupt NFS file accesses).

If a process remains in uninterruptible sleep for a long time, you can get information about what it's doing by attaching a debugger to it, by running a diagnostic tool such as strace or dtrace (or similar tools, depending on your unix flavor), or with other diagnostic mechanisms such as /proc/PID/syscall under Linux. See Can't kill wget process with `kill -9` for more discussion of how to investigate a process in uninterruptible sleep.

You may sometimes see entries marked Z (or H under Linux, I don't know what the distinction is) in the ps or top output. These are technically not processes, they are zombie processes, which are nothing more than an entry in the process table, kept around so that the parent process can be notified of the death of its child. They will go away when the parent process pays attention (or dies).


شاهد الفيديو: شرح اساسيات لغة بايثون 3: الدرس السابع